4880 lines
241 KiB
Python
4880 lines
241 KiB
Python
r"""Wrapper for tox.h
|
|
|
|
Generated with:
|
|
/usr/local/lib/python3.11/site-packages/ctypesgen/__main__.py -o src/tox_wrapper/tox_ctypesgen.py -L/usr/local/lib -llibtoxcore -lsodium -lopus -lvpx -lnsl -ltirpc /usr/local/src/c-toxcore/toxcore/tox.h /usr/local/src/c-toxcore/toxav/toxav.h /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h
|
|
|
|
Do not modify this file.
|
|
"""
|
|
|
|
__docformat__ = "restructuredtext"
|
|
|
|
# Begin preamble for Python
|
|
|
|
import ctypes
|
|
import sys
|
|
from ctypes import * # noqa: F401, F403
|
|
|
|
# callbacks can be called in any thread so we are being careful
|
|
# NOT to use logging. tox.py can also be called by callbacks.
|
|
def LOG_ERROR(a) -> None:
|
|
print('EROR> '+a)
|
|
def LOG_WARN(a) -> None:
|
|
print('WARN> '+a)
|
|
def LOG_INFO(a) -> None:
|
|
bVERBOSE = hasattr(__builtins__, 'app') and app.oArgs.loglevel <= 20
|
|
if bVERBOSE: print('INFO> '+a)
|
|
def LOG_DEBUG(a) -> None:
|
|
bVERBOSE = hasattr(__builtins__, 'app') and app.oArgs.loglevel <= 10
|
|
if bVERBOSE: print('DBUG> '+a)
|
|
def LOG_TRACE(a) -> None:
|
|
bVERBOSE = hasattr(__builtins__, 'app') and app.oArgs.loglevel < 10
|
|
if bVERBOSE: print('TRAC> '+a)
|
|
|
|
_int_types = (ctypes.c_int16, ctypes.c_int32)
|
|
if hasattr(ctypes, "c_int64"):
|
|
# Some builds of ctypes apparently do not have ctypes.c_int64
|
|
# defined; it's a pretty good bet that these builds do not
|
|
# have 64-bit pointers.
|
|
_int_types += (ctypes.c_int64,)
|
|
for t in _int_types:
|
|
if ctypes.sizeof(t) == ctypes.sizeof(ctypes.c_size_t):
|
|
c_ptrdiff_t = t
|
|
del t
|
|
del _int_types
|
|
|
|
|
|
|
|
class UserString:
|
|
def __init__(self, seq):
|
|
if isinstance(seq, bytes):
|
|
self.data = seq
|
|
elif isinstance(seq, UserString):
|
|
self.data = seq.data[:]
|
|
else:
|
|
self.data = str(seq).encode()
|
|
|
|
def __bytes__(self):
|
|
return self.data
|
|
|
|
def __str__(self):
|
|
return self.data.decode()
|
|
|
|
def __repr__(self):
|
|
return repr(self.data)
|
|
|
|
def __int__(self):
|
|
return int(self.data.decode())
|
|
|
|
def __long__(self):
|
|
return int(self.data.decode())
|
|
|
|
def __float__(self):
|
|
return float(self.data.decode())
|
|
|
|
def __complex__(self):
|
|
return complex(self.data.decode())
|
|
|
|
def __hash__(self):
|
|
return hash(self.data)
|
|
|
|
def __le__(self, string):
|
|
if isinstance(string, UserString):
|
|
return self.data <= string.data
|
|
else:
|
|
return self.data <= string
|
|
|
|
def __lt__(self, string):
|
|
if isinstance(string, UserString):
|
|
return self.data < string.data
|
|
else:
|
|
return self.data < string
|
|
|
|
def __ge__(self, string):
|
|
if isinstance(string, UserString):
|
|
return self.data >= string.data
|
|
else:
|
|
return self.data >= string
|
|
|
|
def __gt__(self, string):
|
|
if isinstance(string, UserString):
|
|
return self.data > string.data
|
|
else:
|
|
return self.data > string
|
|
|
|
def __eq__(self, string):
|
|
if isinstance(string, UserString):
|
|
return self.data == string.data
|
|
else:
|
|
return self.data == string
|
|
|
|
def __ne__(self, string):
|
|
if isinstance(string, UserString):
|
|
return self.data != string.data
|
|
else:
|
|
return self.data != string
|
|
|
|
def __contains__(self, char):
|
|
return char in self.data
|
|
|
|
def __len__(self):
|
|
return len(self.data)
|
|
|
|
def __getitem__(self, index):
|
|
return self.__class__(self.data[index])
|
|
|
|
def __getslice__(self, start, end):
|
|
start = max(start, 0)
|
|
end = max(end, 0)
|
|
return self.__class__(self.data[start:end])
|
|
|
|
def __add__(self, other):
|
|
if isinstance(other, UserString):
|
|
return self.__class__(self.data + other.data)
|
|
elif isinstance(other, bytes):
|
|
return self.__class__(self.data + other)
|
|
else:
|
|
return self.__class__(self.data + str(other).encode())
|
|
|
|
def __radd__(self, other):
|
|
if isinstance(other, bytes):
|
|
return self.__class__(other + self.data)
|
|
else:
|
|
return self.__class__(str(other).encode() + self.data)
|
|
|
|
def __mul__(self, n):
|
|
return self.__class__(self.data * n)
|
|
|
|
__rmul__ = __mul__
|
|
|
|
def __mod__(self, args):
|
|
return self.__class__(self.data % args)
|
|
|
|
# the following methods are defined in alphabetical order:
|
|
def capitalize(self):
|
|
return self.__class__(self.data.capitalize())
|
|
|
|
def center(self, width, *args):
|
|
return self.__class__(self.data.center(width, *args))
|
|
|
|
def count(self, sub, start=0, end=sys.maxsize):
|
|
return self.data.count(sub, start, end)
|
|
|
|
def decode(self, encoding=None, errors=None): # XXX improve this?
|
|
if encoding:
|
|
if errors:
|
|
return self.__class__(self.data.decode(encoding, errors))
|
|
else:
|
|
return self.__class__(self.data.decode(encoding))
|
|
else:
|
|
return self.__class__(self.data.decode())
|
|
|
|
def encode(self, encoding=None, errors=None): # XXX improve this?
|
|
if encoding:
|
|
if errors:
|
|
return self.__class__(self.data.encode(encoding, errors))
|
|
else:
|
|
return self.__class__(self.data.encode(encoding))
|
|
else:
|
|
return self.__class__(self.data.encode())
|
|
|
|
def endswith(self, suffix, start=0, end=sys.maxsize):
|
|
return self.data.endswith(suffix, start, end)
|
|
|
|
def expandtabs(self, tabsize=8):
|
|
return self.__class__(self.data.expandtabs(tabsize))
|
|
|
|
def find(self, sub, start=0, end=sys.maxsize):
|
|
return self.data.find(sub, start, end)
|
|
|
|
def index(self, sub, start=0, end=sys.maxsize):
|
|
return self.data.index(sub, start, end)
|
|
|
|
def isalpha(self):
|
|
return self.data.isalpha()
|
|
|
|
def isalnum(self):
|
|
return self.data.isalnum()
|
|
|
|
def isdecimal(self):
|
|
return self.data.isdecimal()
|
|
|
|
def isdigit(self):
|
|
return self.data.isdigit()
|
|
|
|
def islower(self):
|
|
return self.data.islower()
|
|
|
|
def isnumeric(self):
|
|
return self.data.isnumeric()
|
|
|
|
def isspace(self):
|
|
return self.data.isspace()
|
|
|
|
def istitle(self):
|
|
return self.data.istitle()
|
|
|
|
def isupper(self):
|
|
return self.data.isupper()
|
|
|
|
def join(self, seq):
|
|
return self.data.join(seq)
|
|
|
|
def ljust(self, width, *args):
|
|
return self.__class__(self.data.ljust(width, *args))
|
|
|
|
def lower(self):
|
|
return self.__class__(self.data.lower())
|
|
|
|
def lstrip(self, chars=None):
|
|
return self.__class__(self.data.lstrip(chars))
|
|
|
|
def partition(self, sep):
|
|
return self.data.partition(sep)
|
|
|
|
def replace(self, old, new, maxsplit=-1):
|
|
return self.__class__(self.data.replace(old, new, maxsplit))
|
|
|
|
def rfind(self, sub, start=0, end=sys.maxsize):
|
|
return self.data.rfind(sub, start, end)
|
|
|
|
def rindex(self, sub, start=0, end=sys.maxsize):
|
|
return self.data.rindex(sub, start, end)
|
|
|
|
def rjust(self, width, *args):
|
|
return self.__class__(self.data.rjust(width, *args))
|
|
|
|
def rpartition(self, sep):
|
|
return self.data.rpartition(sep)
|
|
|
|
def rstrip(self, chars=None):
|
|
return self.__class__(self.data.rstrip(chars))
|
|
|
|
def split(self, sep=None, maxsplit=-1):
|
|
return self.data.split(sep, maxsplit)
|
|
|
|
def rsplit(self, sep=None, maxsplit=-1):
|
|
return self.data.rsplit(sep, maxsplit)
|
|
|
|
def splitlines(self, keepends=0):
|
|
return self.data.splitlines(keepends)
|
|
|
|
def startswith(self, prefix, start=0, end=sys.maxsize):
|
|
return self.data.startswith(prefix, start, end)
|
|
|
|
def strip(self, chars=None):
|
|
return self.__class__(self.data.strip(chars))
|
|
|
|
def swapcase(self):
|
|
return self.__class__(self.data.swapcase())
|
|
|
|
def title(self):
|
|
return self.__class__(self.data.title())
|
|
|
|
def translate(self, *args):
|
|
return self.__class__(self.data.translate(*args))
|
|
|
|
def upper(self):
|
|
return self.__class__(self.data.upper())
|
|
|
|
def zfill(self, width):
|
|
return self.__class__(self.data.zfill(width))
|
|
|
|
|
|
class MutableString(UserString):
|
|
"""mutable string objects
|
|
|
|
Python strings are immutable objects. This has the advantage, that
|
|
strings may be used as dictionary keys. If this property isn't needed
|
|
and you insist on changing string values in place instead, you may cheat
|
|
and use MutableString.
|
|
|
|
But the purpose of this class is an educational one: to prevent
|
|
people from inventing their own mutable string class derived
|
|
from UserString and than forget thereby to remove (override) the
|
|
__hash__ method inherited from UserString. This would lead to
|
|
errors that would be very hard to track down.
|
|
|
|
A faster and better solution is to rewrite your program using lists."""
|
|
|
|
def __init__(self, string=""):
|
|
self.data = string
|
|
|
|
def __hash__(self):
|
|
raise TypeError("unhashable type (it is mutable)")
|
|
|
|
def __setitem__(self, index, sub):
|
|
if index < 0:
|
|
index += len(self.data)
|
|
if index < 0 or index >= len(self.data):
|
|
raise IndexError
|
|
self.data = self.data[:index] + sub + self.data[index + 1 :]
|
|
|
|
def __delitem__(self, index):
|
|
if index < 0:
|
|
index += len(self.data)
|
|
if index < 0 or index >= len(self.data):
|
|
raise IndexError
|
|
self.data = self.data[:index] + self.data[index + 1 :]
|
|
|
|
def __setslice__(self, start, end, sub):
|
|
start = max(start, 0)
|
|
end = max(end, 0)
|
|
if isinstance(sub, UserString):
|
|
self.data = self.data[:start] + sub.data + self.data[end:]
|
|
elif isinstance(sub, bytes):
|
|
self.data = self.data[:start] + sub + self.data[end:]
|
|
else:
|
|
self.data = self.data[:start] + str(sub).encode() + self.data[end:]
|
|
|
|
def __delslice__(self, start, end):
|
|
start = max(start, 0)
|
|
end = max(end, 0)
|
|
self.data = self.data[:start] + self.data[end:]
|
|
|
|
def immutable(self):
|
|
return UserString(self.data)
|
|
|
|
def __iadd__(self, other):
|
|
if isinstance(other, UserString):
|
|
self.data += other.data
|
|
elif isinstance(other, bytes):
|
|
self.data += other
|
|
else:
|
|
self.data += str(other).encode()
|
|
return self
|
|
|
|
def __imul__(self, n):
|
|
self.data *= n
|
|
return self
|
|
|
|
|
|
class String(MutableString, ctypes.Union):
|
|
_fields_ = [("raw", ctypes.POINTER(ctypes.c_char)), ("data", ctypes.c_char_p)]
|
|
|
|
def __init__(self, obj=b""):
|
|
if isinstance(obj, (bytes, UserString)):
|
|
self.data = bytes(obj)
|
|
else:
|
|
self.raw = obj
|
|
|
|
def __len__(self):
|
|
return self.data and len(self.data) or 0
|
|
|
|
def from_param(cls, obj):
|
|
# Convert None or 0
|
|
if obj is None or obj == 0:
|
|
return cls(ctypes.POINTER(ctypes.c_char)())
|
|
|
|
# Convert from String
|
|
elif isinstance(obj, String):
|
|
return obj
|
|
|
|
# Convert from bytes
|
|
elif isinstance(obj, bytes):
|
|
return cls(obj)
|
|
|
|
# Convert from str
|
|
elif isinstance(obj, str):
|
|
return cls(obj.encode())
|
|
|
|
# Convert from c_char_p
|
|
elif isinstance(obj, ctypes.c_char_p):
|
|
return obj
|
|
|
|
# Convert from POINTER(ctypes.c_char)
|
|
elif isinstance(obj, ctypes.POINTER(ctypes.c_char)):
|
|
return obj
|
|
|
|
# Convert from raw pointer
|
|
elif isinstance(obj, int):
|
|
return cls(ctypes.cast(obj, ctypes.POINTER(ctypes.c_char)))
|
|
|
|
# Convert from ctypes.c_char array
|
|
elif isinstance(obj, ctypes.c_char * len(obj)):
|
|
return obj
|
|
|
|
# Convert from object
|
|
else:
|
|
return String.from_param(obj._as_parameter_)
|
|
|
|
from_param = classmethod(from_param)
|
|
|
|
|
|
def ReturnString(obj, func=None, arguments=None):
|
|
return String.from_param(obj)
|
|
|
|
|
|
# As of ctypes 1.0, ctypes does not support custom error-checking
|
|
# functions on callbacks, nor does it support custom datatypes on
|
|
# callbacks, so we must ensure that all callbacks return
|
|
# primitive datatypes.
|
|
#
|
|
# Non-primitive return values wrapped with UNCHECKED won't be
|
|
# typechecked, and will be converted to ctypes.c_void_p.
|
|
def UNCHECKED(type):
|
|
if hasattr(type, "_type_") and isinstance(type._type_, str) and type._type_ != "P":
|
|
return type
|
|
else:
|
|
return ctypes.c_void_p
|
|
|
|
|
|
# ctypes doesn't have direct support for variadic functions, so we have to write
|
|
# our own wrapper class
|
|
class _variadic_function(object):
|
|
def __init__(self, func, restype, argtypes, errcheck):
|
|
self.func = func
|
|
self.func.restype = restype
|
|
self.argtypes = argtypes
|
|
if errcheck:
|
|
self.func.errcheck = errcheck
|
|
|
|
def _as_parameter_(self):
|
|
# So we can pass this variadic function as a function pointer
|
|
return self.func
|
|
|
|
def __call__(self, *args):
|
|
fixed_args = []
|
|
i = 0
|
|
for argtype in self.argtypes:
|
|
# Typecheck what we can
|
|
fixed_args.append(argtype.from_param(args[i]))
|
|
i += 1
|
|
return self.func(*fixed_args + list(args[i:]))
|
|
|
|
|
|
def ord_if_char(value):
|
|
"""
|
|
Simple helper used for casts to simple builtin types: if the argument is a
|
|
string type, it will be converted to it's ordinal value.
|
|
|
|
This function will raise an exception if the argument is string with more
|
|
than one characters.
|
|
"""
|
|
return ord(value) if (isinstance(value, bytes) or isinstance(value, str)) else value
|
|
|
|
# End preamble
|
|
|
|
_libs = {}
|
|
_libdirs = ['/usr/local/lib']
|
|
|
|
# Begin loader
|
|
|
|
"""
|
|
Load libraries - appropriately for all our supported platforms
|
|
"""
|
|
# ----------------------------------------------------------------------------
|
|
# Copyright (c) 2008 David James
|
|
# Copyright (c) 2006-2008 Alex Holkner
|
|
# All rights reserved.
|
|
#
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions
|
|
# are met:
|
|
#
|
|
# * Redistributions of source code must retain the above copyright
|
|
# notice, this list of conditions and the following disclaimer.
|
|
# * Redistributions in binary form must reproduce the above copyright
|
|
# notice, this list of conditions and the following disclaimer in
|
|
# the documentation and/or other materials provided with the
|
|
# distribution.
|
|
# * Neither the name of pyglet nor the names of its
|
|
# contributors may be used to endorse or promote products
|
|
# derived from this software without specific prior written
|
|
# permission.
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
|
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
# POSSIBILITY OF SUCH DAMAGE.
|
|
# ----------------------------------------------------------------------------
|
|
|
|
import ctypes
|
|
import ctypes.util
|
|
import glob
|
|
import os.path
|
|
import platform
|
|
import re
|
|
import sys
|
|
|
|
|
|
def _environ_path(name):
|
|
"""Split an environment variable into a path-like list elements"""
|
|
if name in os.environ:
|
|
return os.environ[name].split(":")
|
|
return []
|
|
|
|
|
|
class LibraryLoader:
|
|
"""
|
|
A base class For loading of libraries ;-)
|
|
Subclasses load libraries for specific platforms.
|
|
"""
|
|
|
|
# library names formatted specifically for platforms
|
|
name_formats = ["%s"]
|
|
|
|
class Lookup:
|
|
"""Looking up calling conventions for a platform"""
|
|
|
|
mode = ctypes.DEFAULT_MODE
|
|
|
|
def __init__(self, path):
|
|
super(LibraryLoader.Lookup, self).__init__()
|
|
self.access = dict(cdecl=ctypes.CDLL(path, self.mode))
|
|
|
|
def get(self, name, calling_convention="cdecl"):
|
|
"""Return the given name according to the selected calling convention"""
|
|
if calling_convention not in self.access:
|
|
raise LookupError(
|
|
"Unknown calling convention '{}' for function '{}'".format(
|
|
calling_convention, name
|
|
)
|
|
)
|
|
return getattr(self.access[calling_convention], name)
|
|
|
|
def has(self, name, calling_convention="cdecl"):
|
|
"""Return True if this given calling convention finds the given 'name'"""
|
|
if calling_convention not in self.access:
|
|
return False
|
|
return hasattr(self.access[calling_convention], name)
|
|
|
|
def __getattr__(self, name):
|
|
return getattr(self.access["cdecl"], name)
|
|
|
|
def __init__(self):
|
|
self.other_dirs = []
|
|
|
|
def __call__(self, libname):
|
|
"""Given the name of a library, load it."""
|
|
paths = self.getpaths(libname)
|
|
|
|
for path in paths:
|
|
# noinspection PyBroadException
|
|
try:
|
|
return self.Lookup(path)
|
|
except Exception: # pylint: disable=broad-except
|
|
pass
|
|
|
|
raise ImportError("Could not load %s." % libname)
|
|
|
|
def getpaths(self, libname):
|
|
"""Return a list of paths where the library might be found."""
|
|
if os.path.isabs(libname):
|
|
yield libname
|
|
else:
|
|
# search through a prioritized series of locations for the library
|
|
|
|
# we first search any specific directories identified by user
|
|
for dir_i in self.other_dirs:
|
|
for fmt in self.name_formats:
|
|
# dir_i should be absolute already
|
|
yield os.path.join(dir_i, fmt % libname)
|
|
|
|
# check if this code is even stored in a physical file
|
|
try:
|
|
this_file = __file__
|
|
except NameError:
|
|
this_file = None
|
|
|
|
# then we search the directory where the generated python interface is stored
|
|
if this_file is not None:
|
|
for fmt in self.name_formats:
|
|
yield os.path.abspath(os.path.join(os.path.dirname(__file__), fmt % libname))
|
|
|
|
# now, use the ctypes tools to try to find the library
|
|
for fmt in self.name_formats:
|
|
path = ctypes.util.find_library(fmt % libname)
|
|
if path:
|
|
yield path
|
|
|
|
# then we search all paths identified as platform-specific lib paths
|
|
for path in self.getplatformpaths(libname):
|
|
yield path
|
|
|
|
# Finally, we'll try the users current working directory
|
|
for fmt in self.name_formats:
|
|
yield os.path.abspath(os.path.join(os.path.curdir, fmt % libname))
|
|
|
|
def getplatformpaths(self, _libname): # pylint: disable=no-self-use
|
|
"""Return all the library paths available in this platform"""
|
|
return []
|
|
|
|
|
|
# Darwin (Mac OS X)
|
|
|
|
|
|
class DarwinLibraryLoader(LibraryLoader):
|
|
"""Library loader for MacOS"""
|
|
|
|
name_formats = [
|
|
"lib%s.dylib",
|
|
"lib%s.so",
|
|
"lib%s.bundle",
|
|
"%s.dylib",
|
|
"%s.so",
|
|
"%s.bundle",
|
|
"%s",
|
|
]
|
|
|
|
class Lookup(LibraryLoader.Lookup):
|
|
"""
|
|
Looking up library files for this platform (Darwin aka MacOS)
|
|
"""
|
|
|
|
# Darwin requires dlopen to be called with mode RTLD_GLOBAL instead
|
|
# of the default RTLD_LOCAL. Without this, you end up with
|
|
# libraries not being loadable, resulting in "Symbol not found"
|
|
# errors
|
|
mode = ctypes.RTLD_GLOBAL
|
|
|
|
def getplatformpaths(self, libname):
|
|
if os.path.pathsep in libname:
|
|
names = [libname]
|
|
else:
|
|
names = [fmt % libname for fmt in self.name_formats]
|
|
|
|
for directory in self.getdirs(libname):
|
|
for name in names:
|
|
yield os.path.join(directory, name)
|
|
|
|
@staticmethod
|
|
def getdirs(libname):
|
|
"""Implements the dylib search as specified in Apple documentation:
|
|
|
|
http://developer.apple.com/documentation/DeveloperTools/Conceptual/
|
|
DynamicLibraries/Articles/DynamicLibraryUsageGuidelines.html
|
|
|
|
Before commencing the standard search, the method first checks
|
|
the bundle's ``Frameworks`` directory if the application is running
|
|
within a bundle (OS X .app).
|
|
"""
|
|
|
|
dyld_fallback_library_path = _environ_path("DYLD_FALLBACK_LIBRARY_PATH")
|
|
if not dyld_fallback_library_path:
|
|
dyld_fallback_library_path = [
|
|
os.path.expanduser("~/lib"),
|
|
"/usr/local/lib",
|
|
"/usr/lib",
|
|
]
|
|
|
|
dirs = []
|
|
|
|
if "/" in libname:
|
|
dirs.extend(_environ_path("DYLD_LIBRARY_PATH"))
|
|
else:
|
|
dirs.extend(_environ_path("LD_LIBRARY_PATH"))
|
|
dirs.extend(_environ_path("DYLD_LIBRARY_PATH"))
|
|
dirs.extend(_environ_path("LD_RUN_PATH"))
|
|
|
|
if hasattr(sys, "frozen") and getattr(sys, "frozen") == "macosx_app":
|
|
dirs.append(os.path.join(os.environ["RESOURCEPATH"], "..", "Frameworks"))
|
|
|
|
dirs.extend(dyld_fallback_library_path)
|
|
|
|
return dirs
|
|
|
|
|
|
# Posix
|
|
|
|
|
|
class PosixLibraryLoader(LibraryLoader):
|
|
"""Library loader for POSIX-like systems (including Linux)"""
|
|
|
|
_ld_so_cache = None
|
|
|
|
_include = re.compile(r"^\s*include\s+(?P<pattern>.*)")
|
|
|
|
name_formats = ["lib%s.so", "%s.so", "%s"]
|
|
|
|
class _Directories(dict):
|
|
"""Deal with directories"""
|
|
|
|
def __init__(self):
|
|
dict.__init__(self)
|
|
self.order = 0
|
|
|
|
def add(self, directory):
|
|
"""Add a directory to our current set of directories"""
|
|
if len(directory) > 1:
|
|
directory = directory.rstrip(os.path.sep)
|
|
# only adds and updates order if exists and not already in set
|
|
if not os.path.exists(directory):
|
|
return
|
|
order = self.setdefault(directory, self.order)
|
|
if order == self.order:
|
|
self.order += 1
|
|
|
|
def extend(self, directories):
|
|
"""Add a list of directories to our set"""
|
|
for a_dir in directories:
|
|
self.add(a_dir)
|
|
|
|
def ordered(self):
|
|
"""Sort the list of directories"""
|
|
return (i[0] for i in sorted(self.items(), key=lambda d: d[1]))
|
|
|
|
def _get_ld_so_conf_dirs(self, conf, dirs):
|
|
"""
|
|
Recursive function to help parse all ld.so.conf files, including proper
|
|
handling of the `include` directive.
|
|
"""
|
|
|
|
try:
|
|
with open(conf) as fileobj:
|
|
for dirname in fileobj:
|
|
dirname = dirname.strip()
|
|
if not dirname:
|
|
continue
|
|
|
|
match = self._include.match(dirname)
|
|
if not match:
|
|
dirs.add(dirname)
|
|
else:
|
|
for dir2 in glob.glob(match.group("pattern")):
|
|
self._get_ld_so_conf_dirs(dir2, dirs)
|
|
except IOError:
|
|
pass
|
|
|
|
def _create_ld_so_cache(self):
|
|
# Recreate search path followed by ld.so. This is going to be
|
|
# slow to build, and incorrect (ld.so uses ld.so.cache, which may
|
|
# not be up-to-date). Used only as fallback for distros without
|
|
# /sbin/ldconfig.
|
|
#
|
|
# We assume the DT_RPATH and DT_RUNPATH binary sections are omitted.
|
|
|
|
directories = self._Directories()
|
|
for name in (
|
|
"LD_LIBRARY_PATH",
|
|
"SHLIB_PATH", # HP-UX
|
|
"LIBPATH", # OS/2, AIX
|
|
"LIBRARY_PATH", # BE/OS
|
|
):
|
|
if name in os.environ:
|
|
directories.extend(os.environ[name].split(os.pathsep))
|
|
|
|
self._get_ld_so_conf_dirs("/etc/ld.so.conf", directories)
|
|
|
|
bitage = platform.architecture()[0]
|
|
|
|
unix_lib_dirs_list = []
|
|
if bitage.startswith("64"):
|
|
# prefer 64 bit if that is our arch
|
|
unix_lib_dirs_list += ["/lib64", "/usr/lib64"]
|
|
|
|
# must include standard libs, since those paths are also used by 64 bit
|
|
# installs
|
|
unix_lib_dirs_list += ["/lib", "/usr/lib"]
|
|
if sys.platform.startswith("linux"):
|
|
# Try and support multiarch work in Ubuntu
|
|
# https://wiki.ubuntu.com/MultiarchSpec
|
|
if bitage.startswith("32"):
|
|
# Assume Intel/AMD x86 compat
|
|
unix_lib_dirs_list += ["/lib/i386-linux-gnu", "/usr/lib/i386-linux-gnu"]
|
|
elif bitage.startswith("64"):
|
|
# Assume Intel/AMD x86 compatible
|
|
unix_lib_dirs_list += [
|
|
"/lib/x86_64-linux-gnu",
|
|
"/usr/lib/x86_64-linux-gnu",
|
|
]
|
|
else:
|
|
# guess...
|
|
unix_lib_dirs_list += glob.glob("/lib/*linux-gnu")
|
|
directories.extend(unix_lib_dirs_list)
|
|
|
|
cache = {}
|
|
lib_re = re.compile(r"lib(.*)\.s[ol]")
|
|
# ext_re = re.compile(r"\.s[ol]$")
|
|
for our_dir in directories.ordered():
|
|
try:
|
|
for path in glob.glob("%s/*.s[ol]*" % our_dir):
|
|
file = os.path.basename(path)
|
|
|
|
# Index by filename
|
|
cache_i = cache.setdefault(file, set())
|
|
cache_i.add(path)
|
|
|
|
# Index by library name
|
|
match = lib_re.match(file)
|
|
if match:
|
|
library = match.group(1)
|
|
cache_i = cache.setdefault(library, set())
|
|
cache_i.add(path)
|
|
except OSError:
|
|
pass
|
|
|
|
self._ld_so_cache = cache
|
|
|
|
def getplatformpaths(self, libname):
|
|
if self._ld_so_cache is None:
|
|
self._create_ld_so_cache()
|
|
|
|
result = self._ld_so_cache.get(libname, set())
|
|
for i in result:
|
|
# we iterate through all found paths for library, since we may have
|
|
# actually found multiple architectures or other library types that
|
|
# may not load
|
|
yield i
|
|
|
|
|
|
# Windows
|
|
|
|
|
|
class WindowsLibraryLoader(LibraryLoader):
|
|
"""Library loader for Microsoft Windows"""
|
|
|
|
name_formats = ["%s.dll", "lib%s.dll", "%slib.dll", "%s"]
|
|
|
|
class Lookup(LibraryLoader.Lookup):
|
|
"""Lookup class for Windows libraries..."""
|
|
|
|
def __init__(self, path):
|
|
super(WindowsLibraryLoader.Lookup, self).__init__(path)
|
|
self.access["stdcall"] = ctypes.windll.LoadLibrary(path)
|
|
|
|
|
|
# Platform switching
|
|
|
|
# If your value of sys.platform does not appear in this dict, please contact
|
|
# the Ctypesgen maintainers.
|
|
|
|
loaderclass = {
|
|
"darwin": DarwinLibraryLoader,
|
|
"cygwin": WindowsLibraryLoader,
|
|
"win32": WindowsLibraryLoader,
|
|
"msys": WindowsLibraryLoader,
|
|
}
|
|
|
|
load_library = loaderclass.get(sys.platform, PosixLibraryLoader)()
|
|
|
|
|
|
def add_library_search_dirs(other_dirs):
|
|
"""
|
|
Add libraries to search paths.
|
|
If library paths are relative, convert them to absolute with respect to this
|
|
file's directory
|
|
"""
|
|
for path in other_dirs:
|
|
if not os.path.isabs(path):
|
|
path = os.path.abspath(path)
|
|
load_library.other_dirs.append(path)
|
|
|
|
|
|
del loaderclass
|
|
|
|
# End loader
|
|
|
|
add_library_search_dirs(['/usr/local/lib'])
|
|
|
|
# Begin libraries
|
|
_libs["libtoxcore"] = load_library("libtoxcore")
|
|
|
|
# 6 libraries
|
|
# End libraries
|
|
|
|
# No modules
|
|
|
|
__uint8_t = c_ubyte# /usr/include/bits/types.h: 38
|
|
|
|
__uint16_t = c_ushort# /usr/include/bits/types.h: 40
|
|
|
|
__uint32_t = c_uint# /usr/include/bits/types.h: 42
|
|
|
|
__uint64_t = c_ulong# /usr/include/bits/types.h: 45
|
|
|
|
uint8_t = __uint8_t# /usr/include/bits/stdint-uintn.h: 24
|
|
|
|
uint16_t = __uint16_t# /usr/include/bits/stdint-uintn.h: 25
|
|
|
|
uint32_t = __uint32_t# /usr/include/bits/stdint-uintn.h: 26
|
|
|
|
uint64_t = __uint64_t# /usr/include/bits/stdint-uintn.h: 27
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 124
|
|
class struct_Tox(Structure):
|
|
pass
|
|
|
|
Tox = struct_Tox# /usr/local/src/c-toxcore/toxcore/tox.h: 124
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 142
|
|
if _libs["libtoxcore"].has("tox_version_major", "cdecl"):
|
|
tox_version_major = _libs["libtoxcore"].get("tox_version_major", "cdecl")
|
|
tox_version_major.argtypes = []
|
|
tox_version_major.restype = uint32_t
|
|
else: LOG_ERROR("tox_version_major")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 152
|
|
if _libs["libtoxcore"].has("tox_version_minor", "cdecl"):
|
|
tox_version_minor = _libs["libtoxcore"].get("tox_version_minor", "cdecl")
|
|
tox_version_minor.argtypes = []
|
|
tox_version_minor.restype = uint32_t
|
|
else: LOG_ERROR("tox_version_minor")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 162
|
|
if _libs["libtoxcore"].has("tox_version_patch", "cdecl"):
|
|
tox_version_patch = _libs["libtoxcore"].get("tox_version_patch", "cdecl")
|
|
tox_version_patch.argtypes = []
|
|
tox_version_patch.restype = uint32_t
|
|
else: LOG_ERROR("tox_version_patch")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 193
|
|
if _libs["libtoxcore"].has("tox_version_is_compatible", "cdecl"):
|
|
tox_version_is_compatible = _libs["libtoxcore"].get("tox_version_is_compatible", "cdecl")
|
|
tox_version_is_compatible.argtypes = [uint32_t, uint32_t, uint32_t]
|
|
tox_version_is_compatible.restype = c_bool
|
|
else: LOG_ERROR("tox_version_is_compatible")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 217
|
|
if _libs["libtoxcore"].has("tox_public_key_size", "cdecl"):
|
|
tox_public_key_size = _libs["libtoxcore"].get("tox_public_key_size", "cdecl")
|
|
tox_public_key_size.argtypes = []
|
|
tox_public_key_size.restype = uint32_t
|
|
else: LOG_ERROR("tox_public_key_size")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 224
|
|
if _libs["libtoxcore"].has("tox_secret_key_size", "cdecl"):
|
|
tox_secret_key_size = _libs["libtoxcore"].get("tox_secret_key_size", "cdecl")
|
|
tox_secret_key_size.argtypes = []
|
|
tox_secret_key_size.restype = uint32_t
|
|
else: LOG_ERROR("tox_secret_key_size")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 233
|
|
if _libs["libtoxcore"].has("tox_conference_uid_size", "cdecl"):
|
|
tox_conference_uid_size = _libs["libtoxcore"].get("tox_conference_uid_size", "cdecl")
|
|
tox_conference_uid_size.argtypes = []
|
|
tox_conference_uid_size.restype = uint32_t
|
|
else: LOG_ERROR("tox_conference_uid_size")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 240
|
|
if _libs["libtoxcore"].has("tox_conference_id_size", "cdecl"):
|
|
tox_conference_id_size = _libs["libtoxcore"].get("tox_conference_id_size", "cdecl")
|
|
tox_conference_id_size.argtypes = []
|
|
tox_conference_id_size.restype = uint32_t
|
|
else: LOG_ERROR("tox_conference_id_size")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 247
|
|
if _libs["libtoxcore"].has("tox_nospam_size", "cdecl"):
|
|
tox_nospam_size = _libs["libtoxcore"].get("tox_nospam_size", "cdecl")
|
|
tox_nospam_size.argtypes = []
|
|
tox_nospam_size.restype = uint32_t
|
|
else: LOG_ERROR("tox_nospam_size")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 261
|
|
if _libs["libtoxcore"].has("tox_address_size", "cdecl"):
|
|
tox_address_size = _libs["libtoxcore"].get("tox_address_size", "cdecl")
|
|
tox_address_size.argtypes = []
|
|
tox_address_size.restype = uint32_t
|
|
else: LOG_ERROR("tox_address_size")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 270
|
|
if _libs["libtoxcore"].has("tox_max_name_length", "cdecl"):
|
|
tox_max_name_length = _libs["libtoxcore"].get("tox_max_name_length", "cdecl")
|
|
tox_max_name_length.argtypes = []
|
|
tox_max_name_length.restype = uint32_t
|
|
else: LOG_ERROR("tox_max_name_length")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 279
|
|
if _libs["libtoxcore"].has("tox_max_status_message_length", "cdecl"):
|
|
tox_max_status_message_length = _libs["libtoxcore"].get("tox_max_status_message_length", "cdecl")
|
|
tox_max_status_message_length.argtypes = []
|
|
tox_max_status_message_length.restype = uint32_t
|
|
else: LOG_ERROR("tox_max_status_message_length")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 288
|
|
if _libs["libtoxcore"].has("tox_max_friend_request_length", "cdecl"):
|
|
tox_max_friend_request_length = _libs["libtoxcore"].get("tox_max_friend_request_length", "cdecl")
|
|
tox_max_friend_request_length.argtypes = []
|
|
tox_max_friend_request_length.restype = uint32_t
|
|
else: LOG_ERROR("tox_max_friend_request_length")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 297
|
|
if _libs["libtoxcore"].has("tox_max_message_length", "cdecl"):
|
|
tox_max_message_length = _libs["libtoxcore"].get("tox_max_message_length", "cdecl")
|
|
tox_max_message_length.argtypes = []
|
|
tox_max_message_length.restype = uint32_t
|
|
else: LOG_ERROR("tox_max_message_length")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 306
|
|
if _libs["libtoxcore"].has("tox_max_custom_packet_size", "cdecl"):
|
|
tox_max_custom_packet_size = _libs["libtoxcore"].get("tox_max_custom_packet_size", "cdecl")
|
|
tox_max_custom_packet_size.argtypes = []
|
|
tox_max_custom_packet_size.restype = uint32_t
|
|
else: LOG_ERROR("tox_max_custom_packet_size")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 313
|
|
if _libs["libtoxcore"].has("tox_hash_length", "cdecl"):
|
|
tox_hash_length = _libs["libtoxcore"].get("tox_hash_length", "cdecl")
|
|
tox_hash_length.argtypes = []
|
|
tox_hash_length.restype = uint32_t
|
|
else: LOG_ERROR("tox_hash_length")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 320
|
|
if _libs["libtoxcore"].has("tox_file_id_length", "cdecl"):
|
|
tox_file_id_length = _libs["libtoxcore"].get("tox_file_id_length", "cdecl")
|
|
tox_file_id_length.argtypes = []
|
|
tox_file_id_length.restype = uint32_t
|
|
else: LOG_ERROR("tox_file_id_length")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 329
|
|
if _libs["libtoxcore"].has("tox_max_filename_length", "cdecl"):
|
|
tox_max_filename_length = _libs["libtoxcore"].get("tox_max_filename_length", "cdecl")
|
|
tox_max_filename_length.argtypes = []
|
|
tox_max_filename_length.restype = uint32_t
|
|
else: LOG_ERROR("tox_max_filename_length")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 341
|
|
if _libs["libtoxcore"].has("tox_max_hostname_length", "cdecl"):
|
|
tox_max_hostname_length = _libs["libtoxcore"].get("tox_max_hostname_length", "cdecl")
|
|
tox_max_hostname_length.argtypes = []
|
|
tox_max_hostname_length.restype = uint32_t
|
|
else: LOG_ERROR("tox_max_hostname_length")
|
|
|
|
enum_Tox_User_Status = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 371
|
|
|
|
TOX_USER_STATUS_NONE = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 371
|
|
|
|
TOX_USER_STATUS_AWAY = (TOX_USER_STATUS_NONE + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 371
|
|
|
|
TOX_USER_STATUS_BUSY = (TOX_USER_STATUS_AWAY + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 371
|
|
|
|
Tox_User_Status = enum_Tox_User_Status# /usr/local/src/c-toxcore/toxcore/tox.h: 371
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 373
|
|
if _libs["libtoxcore"].has("tox_user_status_to_string", "cdecl"):
|
|
tox_user_status_to_string = _libs["libtoxcore"].get("tox_user_status_to_string", "cdecl")
|
|
tox_user_status_to_string.argtypes = [Tox_User_Status]
|
|
tox_user_status_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_user_status_to_string")
|
|
|
|
enum_Tox_Message_Type = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 392
|
|
|
|
TOX_MESSAGE_TYPE_NORMAL = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 392
|
|
|
|
TOX_MESSAGE_TYPE_ACTION = (TOX_MESSAGE_TYPE_NORMAL + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 392
|
|
|
|
Tox_Message_Type = enum_Tox_Message_Type# /usr/local/src/c-toxcore/toxcore/tox.h: 392
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 394
|
|
if _libs["libtoxcore"].has("tox_message_type_to_string", "cdecl"):
|
|
tox_message_type_to_string = _libs["libtoxcore"].get("tox_message_type_to_string", "cdecl")
|
|
tox_message_type_to_string.argtypes = [Tox_Message_Type]
|
|
tox_message_type_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_message_type_to_string")
|
|
|
|
enum_Tox_Proxy_Type = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 422
|
|
|
|
TOX_PROXY_TYPE_NONE = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 422
|
|
|
|
TOX_PROXY_TYPE_HTTP = (TOX_PROXY_TYPE_NONE + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 422
|
|
|
|
TOX_PROXY_TYPE_SOCKS5 = (TOX_PROXY_TYPE_HTTP + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 422
|
|
|
|
Tox_Proxy_Type = enum_Tox_Proxy_Type# /usr/local/src/c-toxcore/toxcore/tox.h: 422
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 424
|
|
if _libs["libtoxcore"].has("tox_proxy_type_to_string", "cdecl"):
|
|
tox_proxy_type_to_string = _libs["libtoxcore"].get("tox_proxy_type_to_string", "cdecl")
|
|
tox_proxy_type_to_string.argtypes = [Tox_Proxy_Type]
|
|
tox_proxy_type_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_proxy_type_to_string")
|
|
|
|
enum_Tox_Savedata_Type = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 446
|
|
|
|
TOX_SAVEDATA_TYPE_NONE = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 446
|
|
|
|
TOX_SAVEDATA_TYPE_TOX_SAVE = (TOX_SAVEDATA_TYPE_NONE + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 446
|
|
|
|
TOX_SAVEDATA_TYPE_SECRET_KEY = (TOX_SAVEDATA_TYPE_TOX_SAVE + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 446
|
|
|
|
Tox_Savedata_Type = enum_Tox_Savedata_Type# /usr/local/src/c-toxcore/toxcore/tox.h: 446
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 448
|
|
if _libs["libtoxcore"].has("tox_savedata_type_to_string", "cdecl"):
|
|
tox_savedata_type_to_string = _libs["libtoxcore"].get("tox_savedata_type_to_string", "cdecl")
|
|
tox_savedata_type_to_string.argtypes = [Tox_Savedata_Type]
|
|
tox_savedata_type_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_savedata_type_to_string")
|
|
|
|
enum_Tox_Log_Level = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 480
|
|
|
|
TOX_LOG_LEVEL_TRACE = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 480
|
|
|
|
TOX_LOG_LEVEL_DEBUG = (TOX_LOG_LEVEL_TRACE + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 480
|
|
|
|
TOX_LOG_LEVEL_INFO = (TOX_LOG_LEVEL_DEBUG + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 480
|
|
|
|
TOX_LOG_LEVEL_WARNING = (TOX_LOG_LEVEL_INFO + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 480
|
|
|
|
TOX_LOG_LEVEL_ERROR = (TOX_LOG_LEVEL_WARNING + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 480
|
|
|
|
Tox_Log_Level = enum_Tox_Log_Level# /usr/local/src/c-toxcore/toxcore/tox.h: 480
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 482
|
|
if _libs["libtoxcore"].has("tox_log_level_to_string", "cdecl"):
|
|
tox_log_level_to_string = _libs["libtoxcore"].get("tox_log_level_to_string", "cdecl")
|
|
tox_log_level_to_string.argtypes = [Tox_Log_Level]
|
|
tox_log_level_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_log_level_to_string")
|
|
|
|
tox_log_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Log_Level, String, uint32_t, String, String, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 505
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 515
|
|
class struct_Tox_System(Structure):
|
|
pass
|
|
|
|
Tox_System = struct_Tox_System# /usr/local/src/c-toxcore/toxcore/tox.h: 515
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 533
|
|
class struct_Tox_Options(Structure):
|
|
pass
|
|
|
|
Tox_Options = struct_Tox_Options# /usr/local/src/c-toxcore/toxcore/tox.h: 532
|
|
|
|
struct_Tox_Options.__slots__ = [
|
|
'ipv6_enabled',
|
|
'udp_enabled',
|
|
'local_discovery_enabled',
|
|
'dht_announcements_enabled',
|
|
'proxy_type',
|
|
'proxy_host',
|
|
'proxy_port',
|
|
'start_port',
|
|
'end_port',
|
|
'tcp_port',
|
|
'hole_punching_enabled',
|
|
'savedata_type',
|
|
'savedata_data',
|
|
'savedata_length',
|
|
'log_callback',
|
|
'log_user_data',
|
|
'experimental_thread_safety',
|
|
'operating_system',
|
|
'experimental_groups_persistence',
|
|
]
|
|
struct_Tox_Options._fields_ = [
|
|
('ipv6_enabled', c_bool),
|
|
('udp_enabled', c_bool),
|
|
('local_discovery_enabled', c_bool),
|
|
('dht_announcements_enabled', c_bool),
|
|
('proxy_type', Tox_Proxy_Type),
|
|
('proxy_host', String),
|
|
('proxy_port', uint16_t),
|
|
('start_port', uint16_t),
|
|
('end_port', uint16_t),
|
|
('tcp_port', uint16_t),
|
|
('hole_punching_enabled', c_bool),
|
|
('savedata_type', Tox_Savedata_Type),
|
|
('savedata_data', POINTER(uint8_t)),
|
|
('savedata_length', c_size_t),
|
|
('log_callback', POINTER(tox_log_cb)),
|
|
('log_user_data', POINTER(None)),
|
|
('experimental_thread_safety', c_bool),
|
|
('operating_system', POINTER(Tox_System)),
|
|
('experimental_groups_persistence', c_bool),
|
|
]
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 694
|
|
if _libs["libtoxcore"].has("tox_options_get_ipv6_enabled", "cdecl"):
|
|
tox_options_get_ipv6_enabled = _libs["libtoxcore"].get("tox_options_get_ipv6_enabled", "cdecl")
|
|
tox_options_get_ipv6_enabled.argtypes = [POINTER(Tox_Options)]
|
|
tox_options_get_ipv6_enabled.restype = c_bool
|
|
else: LOG_ERROR("tox_options_get_ipv6_enabled")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 696
|
|
if _libs["libtoxcore"].has("tox_options_set_ipv6_enabled", "cdecl"):
|
|
tox_options_set_ipv6_enabled = _libs["libtoxcore"].get("tox_options_set_ipv6_enabled", "cdecl")
|
|
tox_options_set_ipv6_enabled.argtypes = [POINTER(Tox_Options), c_bool]
|
|
tox_options_set_ipv6_enabled.restype = None
|
|
else: LOG_ERROR("tox_options_set_ipv6_enabled")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 698
|
|
if _libs["libtoxcore"].has("tox_options_get_udp_enabled", "cdecl"):
|
|
tox_options_get_udp_enabled = _libs["libtoxcore"].get("tox_options_get_udp_enabled", "cdecl")
|
|
tox_options_get_udp_enabled.argtypes = [POINTER(Tox_Options)]
|
|
tox_options_get_udp_enabled.restype = c_bool
|
|
else: LOG_ERROR("tox_options_get_udp_enabled")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 700
|
|
if _libs["libtoxcore"].has("tox_options_set_udp_enabled", "cdecl"):
|
|
tox_options_set_udp_enabled = _libs["libtoxcore"].get("tox_options_set_udp_enabled", "cdecl")
|
|
tox_options_set_udp_enabled.argtypes = [POINTER(Tox_Options), c_bool]
|
|
tox_options_set_udp_enabled.restype = None
|
|
else: LOG_ERROR("tox_options_set_udp_enabled")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 702
|
|
if _libs["libtoxcore"].has("tox_options_get_local_discovery_enabled", "cdecl"):
|
|
tox_options_get_local_discovery_enabled = _libs["libtoxcore"].get("tox_options_get_local_discovery_enabled", "cdecl")
|
|
tox_options_get_local_discovery_enabled.argtypes = [POINTER(Tox_Options)]
|
|
tox_options_get_local_discovery_enabled.restype = c_bool
|
|
else: LOG_ERROR("tox_options_get_local_discovery_enabled")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 704
|
|
if _libs["libtoxcore"].has("tox_options_set_local_discovery_enabled", "cdecl"):
|
|
tox_options_set_local_discovery_enabled = _libs["libtoxcore"].get("tox_options_set_local_discovery_enabled", "cdecl")
|
|
tox_options_set_local_discovery_enabled.argtypes = [POINTER(Tox_Options), c_bool]
|
|
tox_options_set_local_discovery_enabled.restype = None
|
|
else: LOG_ERROR("tox_options_set_local_discovery_enabled")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 706
|
|
if _libs["libtoxcore"].has("tox_options_get_dht_announcements_enabled", "cdecl"):
|
|
tox_options_get_dht_announcements_enabled = _libs["libtoxcore"].get("tox_options_get_dht_announcements_enabled", "cdecl")
|
|
tox_options_get_dht_announcements_enabled.argtypes = [POINTER(Tox_Options)]
|
|
tox_options_get_dht_announcements_enabled.restype = c_bool
|
|
else: LOG_ERROR("tox_options_get_dht_announcements_enabled")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 708
|
|
if _libs["libtoxcore"].has("tox_options_set_dht_announcements_enabled", "cdecl"):
|
|
tox_options_set_dht_announcements_enabled = _libs["libtoxcore"].get("tox_options_set_dht_announcements_enabled", "cdecl")
|
|
tox_options_set_dht_announcements_enabled.argtypes = [POINTER(Tox_Options), c_bool]
|
|
tox_options_set_dht_announcements_enabled.restype = None
|
|
else: LOG_ERROR("tox_options_set_dht_announcements_enabled")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 710
|
|
if _libs["libtoxcore"].has("tox_options_get_proxy_type", "cdecl"):
|
|
tox_options_get_proxy_type = _libs["libtoxcore"].get("tox_options_get_proxy_type", "cdecl")
|
|
tox_options_get_proxy_type.argtypes = [POINTER(Tox_Options)]
|
|
tox_options_get_proxy_type.restype = Tox_Proxy_Type
|
|
else: LOG_ERROR("tox_options_get_proxy_type")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 712
|
|
if _libs["libtoxcore"].has("tox_options_set_proxy_type", "cdecl"):
|
|
tox_options_set_proxy_type = _libs["libtoxcore"].get("tox_options_set_proxy_type", "cdecl")
|
|
tox_options_set_proxy_type.argtypes = [POINTER(Tox_Options), Tox_Proxy_Type]
|
|
tox_options_set_proxy_type.restype = None
|
|
else: LOG_ERROR("tox_options_set_proxy_type")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 714
|
|
if _libs["libtoxcore"].has("tox_options_get_proxy_host", "cdecl"):
|
|
tox_options_get_proxy_host = _libs["libtoxcore"].get("tox_options_get_proxy_host", "cdecl")
|
|
tox_options_get_proxy_host.argtypes = [POINTER(Tox_Options)]
|
|
tox_options_get_proxy_host.restype = c_char_p
|
|
else: LOG_ERROR("tox_options_get_proxy_host")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 716
|
|
if _libs["libtoxcore"].has("tox_options_set_proxy_host", "cdecl"):
|
|
tox_options_set_proxy_host = _libs["libtoxcore"].get("tox_options_set_proxy_host", "cdecl")
|
|
tox_options_set_proxy_host.argtypes = [POINTER(Tox_Options), String]
|
|
tox_options_set_proxy_host.restype = None
|
|
else: LOG_ERROR("tox_options_set_proxy_host")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 718
|
|
if _libs["libtoxcore"].has("tox_options_get_proxy_port", "cdecl"):
|
|
tox_options_get_proxy_port = _libs["libtoxcore"].get("tox_options_get_proxy_port", "cdecl")
|
|
tox_options_get_proxy_port.argtypes = [POINTER(Tox_Options)]
|
|
tox_options_get_proxy_port.restype = uint16_t
|
|
else: LOG_ERROR("tox_options_get_proxy_port")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 720
|
|
if _libs["libtoxcore"].has("tox_options_set_proxy_port", "cdecl"):
|
|
tox_options_set_proxy_port = _libs["libtoxcore"].get("tox_options_set_proxy_port", "cdecl")
|
|
tox_options_set_proxy_port.argtypes = [POINTER(Tox_Options), uint16_t]
|
|
tox_options_set_proxy_port.restype = None
|
|
else: LOG_ERROR("tox_options_set_proxy_port")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 722
|
|
if _libs["libtoxcore"].has("tox_options_get_start_port", "cdecl"):
|
|
tox_options_get_start_port = _libs["libtoxcore"].get("tox_options_get_start_port", "cdecl")
|
|
tox_options_get_start_port.argtypes = [POINTER(Tox_Options)]
|
|
tox_options_get_start_port.restype = uint16_t
|
|
else: LOG_ERROR("tox_options_get_start_port")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 724
|
|
if _libs["libtoxcore"].has("tox_options_set_start_port", "cdecl"):
|
|
tox_options_set_start_port = _libs["libtoxcore"].get("tox_options_set_start_port", "cdecl")
|
|
tox_options_set_start_port.argtypes = [POINTER(Tox_Options), uint16_t]
|
|
tox_options_set_start_port.restype = None
|
|
else: LOG_ERROR("tox_options_set_start_port")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 726
|
|
if _libs["libtoxcore"].has("tox_options_get_end_port", "cdecl"):
|
|
tox_options_get_end_port = _libs["libtoxcore"].get("tox_options_get_end_port", "cdecl")
|
|
tox_options_get_end_port.argtypes = [POINTER(Tox_Options)]
|
|
tox_options_get_end_port.restype = uint16_t
|
|
else: LOG_ERROR("tox_options_get_end_port")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 728
|
|
if _libs["libtoxcore"].has("tox_options_set_end_port", "cdecl"):
|
|
tox_options_set_end_port = _libs["libtoxcore"].get("tox_options_set_end_port", "cdecl")
|
|
tox_options_set_end_port.argtypes = [POINTER(Tox_Options), uint16_t]
|
|
tox_options_set_end_port.restype = None
|
|
else: LOG_ERROR("tox_options_set_end_port")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 730
|
|
if _libs["libtoxcore"].has("tox_options_get_tcp_port", "cdecl"):
|
|
tox_options_get_tcp_port = _libs["libtoxcore"].get("tox_options_get_tcp_port", "cdecl")
|
|
tox_options_get_tcp_port.argtypes = [POINTER(Tox_Options)]
|
|
tox_options_get_tcp_port.restype = uint16_t
|
|
else: LOG_ERROR("tox_options_get_tcp_port")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 732
|
|
if _libs["libtoxcore"].has("tox_options_set_tcp_port", "cdecl"):
|
|
tox_options_set_tcp_port = _libs["libtoxcore"].get("tox_options_set_tcp_port", "cdecl")
|
|
tox_options_set_tcp_port.argtypes = [POINTER(Tox_Options), uint16_t]
|
|
tox_options_set_tcp_port.restype = None
|
|
else: LOG_ERROR("tox_options_set_tcp_port")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 734
|
|
if _libs["libtoxcore"].has("tox_options_get_hole_punching_enabled", "cdecl"):
|
|
tox_options_get_hole_punching_enabled = _libs["libtoxcore"].get("tox_options_get_hole_punching_enabled", "cdecl")
|
|
tox_options_get_hole_punching_enabled.argtypes = [POINTER(Tox_Options)]
|
|
tox_options_get_hole_punching_enabled.restype = c_bool
|
|
else: LOG_ERROR("tox_options_get_hole_punching_enabled")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 736
|
|
if _libs["libtoxcore"].has("tox_options_set_hole_punching_enabled", "cdecl"):
|
|
tox_options_set_hole_punching_enabled = _libs["libtoxcore"].get("tox_options_set_hole_punching_enabled", "cdecl")
|
|
tox_options_set_hole_punching_enabled.argtypes = [POINTER(Tox_Options), c_bool]
|
|
tox_options_set_hole_punching_enabled.restype = None
|
|
else: LOG_ERROR("tox_options_set_hole_punching_enabled")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 738
|
|
if _libs["libtoxcore"].has("tox_options_get_savedata_type", "cdecl"):
|
|
tox_options_get_savedata_type = _libs["libtoxcore"].get("tox_options_get_savedata_type", "cdecl")
|
|
tox_options_get_savedata_type.argtypes = [POINTER(Tox_Options)]
|
|
tox_options_get_savedata_type.restype = Tox_Savedata_Type
|
|
else: LOG_ERROR("tox_options_get_savedata_type")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 740
|
|
if _libs["libtoxcore"].has("tox_options_set_savedata_type", "cdecl"):
|
|
tox_options_set_savedata_type = _libs["libtoxcore"].get("tox_options_set_savedata_type", "cdecl")
|
|
tox_options_set_savedata_type.argtypes = [POINTER(Tox_Options), Tox_Savedata_Type]
|
|
tox_options_set_savedata_type.restype = None
|
|
else: LOG_ERROR("tox_options_set_savedata_type")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 742
|
|
if _libs["libtoxcore"].has("tox_options_get_savedata_data", "cdecl"):
|
|
tox_options_get_savedata_data = _libs["libtoxcore"].get("tox_options_get_savedata_data", "cdecl")
|
|
tox_options_get_savedata_data.argtypes = [POINTER(Tox_Options)]
|
|
tox_options_get_savedata_data.restype = POINTER(uint8_t)
|
|
else: LOG_ERROR("tox_options_get_savedata_data")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 744
|
|
if _libs["libtoxcore"].has("tox_options_set_savedata_data", "cdecl"):
|
|
tox_options_set_savedata_data = _libs["libtoxcore"].get("tox_options_set_savedata_data", "cdecl")
|
|
tox_options_set_savedata_data.argtypes = [POINTER(Tox_Options), POINTER(uint8_t), c_size_t]
|
|
tox_options_set_savedata_data.restype = None
|
|
else: LOG_ERROR("tox_options_set_savedata_data")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 746
|
|
if _libs["libtoxcore"].has("tox_options_get_savedata_length", "cdecl"):
|
|
tox_options_get_savedata_length = _libs["libtoxcore"].get("tox_options_get_savedata_length", "cdecl")
|
|
tox_options_get_savedata_length.argtypes = [POINTER(Tox_Options)]
|
|
tox_options_get_savedata_length.restype = c_size_t
|
|
else: LOG_ERROR("tox_options_get_savedata_length")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 748
|
|
if _libs["libtoxcore"].has("tox_options_set_savedata_length", "cdecl"):
|
|
tox_options_set_savedata_length = _libs["libtoxcore"].get("tox_options_set_savedata_length", "cdecl")
|
|
tox_options_set_savedata_length.argtypes = [POINTER(Tox_Options), c_size_t]
|
|
tox_options_set_savedata_length.restype = None
|
|
else: LOG_ERROR("tox_options_set_savedata_length")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 750
|
|
if _libs["libtoxcore"].has("tox_options_get_log_callback", "cdecl"):
|
|
tox_options_get_log_callback = _libs["libtoxcore"].get("tox_options_get_log_callback", "cdecl")
|
|
tox_options_get_log_callback.argtypes = [POINTER(Tox_Options)]
|
|
tox_options_get_log_callback.restype = POINTER(tox_log_cb)
|
|
else: LOG_ERROR("tox_options_get_log_callback")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 752
|
|
if _libs["libtoxcore"].has("tox_options_set_log_callback", "cdecl"):
|
|
tox_options_set_log_callback = _libs["libtoxcore"].get("tox_options_set_log_callback", "cdecl")
|
|
tox_options_set_log_callback.argtypes = [POINTER(Tox_Options), POINTER(tox_log_cb)]
|
|
tox_options_set_log_callback.restype = None
|
|
else: LOG_ERROR("tox_options_set_log_callback")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 754
|
|
if _libs["libtoxcore"].has("tox_options_get_log_user_data", "cdecl"):
|
|
tox_options_get_log_user_data = _libs["libtoxcore"].get("tox_options_get_log_user_data", "cdecl")
|
|
tox_options_get_log_user_data.argtypes = [POINTER(Tox_Options)]
|
|
tox_options_get_log_user_data.restype = POINTER(c_ubyte)
|
|
tox_options_get_log_user_data.errcheck = lambda v,*a : cast(v, c_void_p)
|
|
else: LOG_ERROR("tox_options_get_log_user_data")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 756
|
|
if _libs["libtoxcore"].has("tox_options_set_log_user_data", "cdecl"):
|
|
tox_options_set_log_user_data = _libs["libtoxcore"].get("tox_options_set_log_user_data", "cdecl")
|
|
tox_options_set_log_user_data.argtypes = [POINTER(Tox_Options), POINTER(None)]
|
|
tox_options_set_log_user_data.restype = None
|
|
else: LOG_ERROR("tox_options_set_log_user_data")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 758
|
|
if _libs["libtoxcore"].has("tox_options_get_experimental_thread_safety", "cdecl"):
|
|
tox_options_get_experimental_thread_safety = _libs["libtoxcore"].get("tox_options_get_experimental_thread_safety", "cdecl")
|
|
tox_options_get_experimental_thread_safety.argtypes = [POINTER(Tox_Options)]
|
|
tox_options_get_experimental_thread_safety.restype = c_bool
|
|
else: LOG_ERROR("tox_options_get_experimental_thread_safety")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 760
|
|
if _libs["libtoxcore"].has("tox_options_set_experimental_thread_safety", "cdecl"):
|
|
tox_options_set_experimental_thread_safety = _libs["libtoxcore"].get("tox_options_set_experimental_thread_safety", "cdecl")
|
|
tox_options_set_experimental_thread_safety.argtypes = [POINTER(Tox_Options), c_bool]
|
|
tox_options_set_experimental_thread_safety.restype = None
|
|
else: LOG_ERROR("tox_options_set_experimental_thread_safety")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 762
|
|
if _libs["libtoxcore"].has("tox_options_get_operating_system", "cdecl"):
|
|
tox_options_get_operating_system = _libs["libtoxcore"].get("tox_options_get_operating_system", "cdecl")
|
|
tox_options_get_operating_system.argtypes = [POINTER(Tox_Options)]
|
|
tox_options_get_operating_system.restype = POINTER(Tox_System)
|
|
else: LOG_ERROR("tox_options_get_operating_system")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 764
|
|
if _libs["libtoxcore"].has("tox_options_set_operating_system", "cdecl"):
|
|
tox_options_set_operating_system = _libs["libtoxcore"].get("tox_options_set_operating_system", "cdecl")
|
|
tox_options_set_operating_system.argtypes = [POINTER(Tox_Options), POINTER(Tox_System)]
|
|
tox_options_set_operating_system.restype = None
|
|
else: LOG_ERROR("tox_options_set_operating_system")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 766
|
|
for _lib in _libs.values():
|
|
if not _lib.has("tox_options_get_experimental_groups_persistence", "cdecl"):
|
|
continue
|
|
tox_options_get_experimental_groups_persistence = _lib.get("tox_options_get_experimental_groups_persistence", "cdecl")
|
|
tox_options_get_experimental_groups_persistence.argtypes = [POINTER(Tox_Options)]
|
|
tox_options_get_experimental_groups_persistence.restype = c_bool
|
|
break
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 768
|
|
for _lib in _libs.values():
|
|
if not _lib.has("tox_options_set_experimental_groups_persistence", "cdecl"):
|
|
continue
|
|
tox_options_set_experimental_groups_persistence = _lib.get("tox_options_set_experimental_groups_persistence", "cdecl")
|
|
tox_options_set_experimental_groups_persistence.argtypes = [POINTER(Tox_Options), c_bool]
|
|
tox_options_set_experimental_groups_persistence.restype = None
|
|
break
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 781
|
|
if _libs["libtoxcore"].has("tox_options_default", "cdecl"):
|
|
tox_options_default = _libs["libtoxcore"].get("tox_options_default", "cdecl")
|
|
tox_options_default.argtypes = [POINTER(Tox_Options)]
|
|
tox_options_default.restype = None
|
|
else: LOG_ERROR("tox_options_default")
|
|
|
|
enum_Tox_Err_Options_New = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 795
|
|
|
|
TOX_ERR_OPTIONS_NEW_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 795
|
|
|
|
TOX_ERR_OPTIONS_NEW_MALLOC = (TOX_ERR_OPTIONS_NEW_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 795
|
|
|
|
Tox_Err_Options_New = enum_Tox_Err_Options_New# /usr/local/src/c-toxcore/toxcore/tox.h: 795
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 797
|
|
if _libs["libtoxcore"].has("tox_err_options_new_to_string", "cdecl"):
|
|
tox_err_options_new_to_string = _libs["libtoxcore"].get("tox_err_options_new_to_string", "cdecl")
|
|
tox_err_options_new_to_string.argtypes = [Tox_Err_Options_New]
|
|
tox_err_options_new_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_options_new_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 811
|
|
if _libs["libtoxcore"].has("tox_options_new", "cdecl"):
|
|
tox_options_new = _libs["libtoxcore"].get("tox_options_new", "cdecl")
|
|
tox_options_new.argtypes = [POINTER(Tox_Err_Options_New)]
|
|
tox_options_new.restype = POINTER(Tox_Options)
|
|
else: LOG_ERROR("tox_options_new")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 819
|
|
if _libs["libtoxcore"].has("tox_options_free", "cdecl"):
|
|
tox_options_free = _libs["libtoxcore"].get("tox_options_free", "cdecl")
|
|
tox_options_free.argtypes = [POINTER(Tox_Options)]
|
|
tox_options_free.restype = None
|
|
else: LOG_ERROR("tox_options_free")
|
|
|
|
enum_Tox_Err_New = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 887
|
|
|
|
TOX_ERR_NEW_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 887
|
|
|
|
TOX_ERR_NEW_NULL = (TOX_ERR_NEW_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 887
|
|
|
|
TOX_ERR_NEW_MALLOC = (TOX_ERR_NEW_NULL + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 887
|
|
|
|
TOX_ERR_NEW_PORT_ALLOC = (TOX_ERR_NEW_MALLOC + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 887
|
|
|
|
TOX_ERR_NEW_PROXY_BAD_TYPE = (TOX_ERR_NEW_PORT_ALLOC + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 887
|
|
|
|
TOX_ERR_NEW_PROXY_BAD_HOST = (TOX_ERR_NEW_PROXY_BAD_TYPE + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 887
|
|
|
|
TOX_ERR_NEW_PROXY_BAD_PORT = (TOX_ERR_NEW_PROXY_BAD_HOST + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 887
|
|
|
|
TOX_ERR_NEW_PROXY_NOT_FOUND = (TOX_ERR_NEW_PROXY_BAD_PORT + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 887
|
|
|
|
TOX_ERR_NEW_LOAD_ENCRYPTED = (TOX_ERR_NEW_PROXY_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 887
|
|
|
|
TOX_ERR_NEW_LOAD_BAD_FORMAT = (TOX_ERR_NEW_LOAD_ENCRYPTED + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 887
|
|
|
|
Tox_Err_New = enum_Tox_Err_New# /usr/local/src/c-toxcore/toxcore/tox.h: 887
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 889
|
|
if _libs["libtoxcore"].has("tox_err_new_to_string", "cdecl"):
|
|
tox_err_new_to_string = _libs["libtoxcore"].get("tox_err_new_to_string", "cdecl")
|
|
tox_err_new_to_string.argtypes = [Tox_Err_New]
|
|
tox_err_new_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_new_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 904
|
|
if _libs["libtoxcore"].has("tox_new", "cdecl"):
|
|
tox_new = _libs["libtoxcore"].get("tox_new", "cdecl")
|
|
tox_new.argtypes = [POINTER(Tox_Options), POINTER(Tox_Err_New)]
|
|
tox_new.restype = POINTER(Tox)
|
|
else: LOG_ERROR("tox_new")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 913
|
|
if _libs["libtoxcore"].has("tox_kill", "cdecl"):
|
|
tox_kill = _libs["libtoxcore"].get("tox_kill", "cdecl")
|
|
tox_kill.argtypes = [POINTER(Tox)]
|
|
tox_kill.restype = None
|
|
else: LOG_ERROR("tox_kill")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 923
|
|
if _libs["libtoxcore"].has("tox_get_savedata_size", "cdecl"):
|
|
tox_get_savedata_size = _libs["libtoxcore"].get("tox_get_savedata_size", "cdecl")
|
|
tox_get_savedata_size.argtypes = [POINTER(Tox)]
|
|
tox_get_savedata_size.restype = c_size_t
|
|
else: LOG_ERROR("tox_get_savedata_size")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 932
|
|
if _libs["libtoxcore"].has("tox_get_savedata", "cdecl"):
|
|
tox_get_savedata = _libs["libtoxcore"].get("tox_get_savedata", "cdecl")
|
|
tox_get_savedata.argtypes = [POINTER(Tox), POINTER(uint8_t)]
|
|
tox_get_savedata.restype = None
|
|
else: LOG_ERROR("tox_get_savedata")
|
|
|
|
enum_Tox_Err_Bootstrap = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 964
|
|
|
|
TOX_ERR_BOOTSTRAP_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 964
|
|
|
|
TOX_ERR_BOOTSTRAP_NULL = (TOX_ERR_BOOTSTRAP_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 964
|
|
|
|
TOX_ERR_BOOTSTRAP_BAD_HOST = (TOX_ERR_BOOTSTRAP_NULL + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 964
|
|
|
|
TOX_ERR_BOOTSTRAP_BAD_PORT = (TOX_ERR_BOOTSTRAP_BAD_HOST + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 964
|
|
|
|
Tox_Err_Bootstrap = enum_Tox_Err_Bootstrap# /usr/local/src/c-toxcore/toxcore/tox.h: 964
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 966
|
|
if _libs["libtoxcore"].has("tox_err_bootstrap_to_string", "cdecl"):
|
|
tox_err_bootstrap_to_string = _libs["libtoxcore"].get("tox_err_bootstrap_to_string", "cdecl")
|
|
tox_err_bootstrap_to_string.argtypes = [Tox_Err_Bootstrap]
|
|
tox_err_bootstrap_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_bootstrap_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 983
|
|
if _libs["libtoxcore"].has("tox_bootstrap", "cdecl"):
|
|
tox_bootstrap = _libs["libtoxcore"].get("tox_bootstrap", "cdecl")
|
|
tox_bootstrap.argtypes = [POINTER(Tox), String, uint16_t, uint8_t * int(32), POINTER(Tox_Err_Bootstrap)]
|
|
tox_bootstrap.restype = c_bool
|
|
else: LOG_ERROR("tox_bootstrap")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 999
|
|
if _libs["libtoxcore"].has("tox_add_tcp_relay", "cdecl"):
|
|
tox_add_tcp_relay = _libs["libtoxcore"].get("tox_add_tcp_relay", "cdecl")
|
|
tox_add_tcp_relay.argtypes = [POINTER(Tox), String, uint16_t, uint8_t * int(32), POINTER(Tox_Err_Bootstrap)]
|
|
tox_add_tcp_relay.restype = c_bool
|
|
else: LOG_ERROR("tox_add_tcp_relay")
|
|
|
|
enum_Tox_Connection = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 1032
|
|
|
|
TOX_CONNECTION_NONE = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 1032
|
|
|
|
TOX_CONNECTION_TCP = (TOX_CONNECTION_NONE + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1032
|
|
|
|
TOX_CONNECTION_UDP = (TOX_CONNECTION_TCP + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1032
|
|
|
|
Tox_Connection = enum_Tox_Connection# /usr/local/src/c-toxcore/toxcore/tox.h: 1032
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1034
|
|
if _libs["libtoxcore"].has("tox_connection_to_string", "cdecl"):
|
|
tox_connection_to_string = _libs["libtoxcore"].get("tox_connection_to_string", "cdecl")
|
|
tox_connection_to_string.argtypes = [Tox_Connection]
|
|
tox_connection_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_connection_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1045
|
|
if _libs["libtoxcore"].has("tox_self_get_connection_status", "cdecl"):
|
|
tox_self_get_connection_status = _libs["libtoxcore"].get("tox_self_get_connection_status", "cdecl")
|
|
tox_self_get_connection_status.argtypes = [POINTER(Tox)]
|
|
tox_self_get_connection_status.restype = Tox_Connection
|
|
else: LOG_ERROR("tox_self_get_connection_status")
|
|
|
|
tox_self_connection_status_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Connection, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 1050
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1065
|
|
if _libs["libtoxcore"].has("tox_callback_self_connection_status", "cdecl"):
|
|
tox_callback_self_connection_status = _libs["libtoxcore"].get("tox_callback_self_connection_status", "cdecl")
|
|
tox_callback_self_connection_status.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_self_connection_status_cb)
|
|
tox_callback_self_connection_status.restype = None
|
|
else: LOG_ERROR("tox_callback_self_connection_status")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1071
|
|
if _libs["libtoxcore"].has("tox_iteration_interval", "cdecl"):
|
|
tox_iteration_interval = _libs["libtoxcore"].get("tox_iteration_interval", "cdecl")
|
|
tox_iteration_interval.argtypes = [POINTER(Tox)]
|
|
tox_iteration_interval.restype = uint32_t
|
|
else: LOG_ERROR("tox_iteration_interval")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1077
|
|
if _libs["libtoxcore"].has("tox_iterate", "cdecl"):
|
|
tox_iterate = _libs["libtoxcore"].get("tox_iterate", "cdecl")
|
|
tox_iterate.argtypes = [POINTER(Tox), POINTER(None)]
|
|
tox_iterate.restype = None
|
|
else: LOG_ERROR("tox_iterate")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1095
|
|
if _libs["libtoxcore"].has("tox_self_get_address", "cdecl"):
|
|
tox_self_get_address = _libs["libtoxcore"].get("tox_self_get_address", "cdecl")
|
|
tox_self_get_address.argtypes = [POINTER(Tox), uint8_t * int(((32 + sizeof(uint32_t)) + sizeof(uint16_t)))]
|
|
tox_self_get_address.restype = None
|
|
else: LOG_ERROR("tox_self_get_address")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1105
|
|
if _libs["libtoxcore"].has("tox_self_set_nospam", "cdecl"):
|
|
tox_self_set_nospam = _libs["libtoxcore"].get("tox_self_set_nospam", "cdecl")
|
|
tox_self_set_nospam.argtypes = [POINTER(Tox), uint32_t]
|
|
tox_self_set_nospam.restype = None
|
|
else: LOG_ERROR("tox_self_set_nospam")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1112
|
|
if _libs["libtoxcore"].has("tox_self_get_nospam", "cdecl"):
|
|
tox_self_get_nospam = _libs["libtoxcore"].get("tox_self_get_nospam", "cdecl")
|
|
tox_self_get_nospam.argtypes = [POINTER(Tox)]
|
|
tox_self_get_nospam.restype = uint32_t
|
|
else: LOG_ERROR("tox_self_get_nospam")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1120
|
|
if _libs["libtoxcore"].has("tox_self_get_public_key", "cdecl"):
|
|
tox_self_get_public_key = _libs["libtoxcore"].get("tox_self_get_public_key", "cdecl")
|
|
tox_self_get_public_key.argtypes = [POINTER(Tox), uint8_t * int(32)]
|
|
tox_self_get_public_key.restype = None
|
|
else: LOG_ERROR("tox_self_get_public_key")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1128
|
|
if _libs["libtoxcore"].has("tox_self_get_secret_key", "cdecl"):
|
|
tox_self_get_secret_key = _libs["libtoxcore"].get("tox_self_get_secret_key", "cdecl")
|
|
tox_self_get_secret_key.argtypes = [POINTER(Tox), uint8_t * int(32)]
|
|
tox_self_get_secret_key.restype = None
|
|
else: LOG_ERROR("tox_self_get_secret_key")
|
|
|
|
enum_Tox_Err_Set_Info = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 1157
|
|
|
|
TOX_ERR_SET_INFO_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 1157
|
|
|
|
TOX_ERR_SET_INFO_NULL = (TOX_ERR_SET_INFO_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1157
|
|
|
|
TOX_ERR_SET_INFO_TOO_LONG = (TOX_ERR_SET_INFO_NULL + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1157
|
|
|
|
Tox_Err_Set_Info = enum_Tox_Err_Set_Info# /usr/local/src/c-toxcore/toxcore/tox.h: 1157
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1159
|
|
if _libs["libtoxcore"].has("tox_err_set_info_to_string", "cdecl"):
|
|
tox_err_set_info_to_string = _libs["libtoxcore"].get("tox_err_set_info_to_string", "cdecl")
|
|
tox_err_set_info_to_string.argtypes = [Tox_Err_Set_Info]
|
|
tox_err_set_info_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_set_info_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1172
|
|
if _libs["libtoxcore"].has("tox_self_set_name", "cdecl"):
|
|
tox_self_set_name = _libs["libtoxcore"].get("tox_self_set_name", "cdecl")
|
|
tox_self_set_name.argtypes = [POINTER(Tox), POINTER(uint8_t), c_size_t, POINTER(Tox_Err_Set_Info)]
|
|
tox_self_set_name.restype = c_bool
|
|
else: LOG_ERROR("tox_self_set_name")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1182
|
|
if _libs["libtoxcore"].has("tox_self_get_name_size", "cdecl"):
|
|
tox_self_get_name_size = _libs["libtoxcore"].get("tox_self_get_name_size", "cdecl")
|
|
tox_self_get_name_size.argtypes = [POINTER(Tox)]
|
|
tox_self_get_name_size.restype = c_size_t
|
|
else: LOG_ERROR("tox_self_get_name_size")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1196
|
|
if _libs["libtoxcore"].has("tox_self_get_name", "cdecl"):
|
|
tox_self_get_name = _libs["libtoxcore"].get("tox_self_get_name", "cdecl")
|
|
tox_self_get_name.argtypes = [POINTER(Tox), POINTER(uint8_t)]
|
|
tox_self_get_name.restype = None
|
|
else: LOG_ERROR("tox_self_get_name")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1205
|
|
if _libs["libtoxcore"].has("tox_self_set_status_message", "cdecl"):
|
|
tox_self_set_status_message = _libs["libtoxcore"].get("tox_self_set_status_message", "cdecl")
|
|
tox_self_set_status_message.argtypes = [POINTER(Tox), POINTER(uint8_t), c_size_t, POINTER(Tox_Err_Set_Info)]
|
|
tox_self_set_status_message.restype = c_bool
|
|
else: LOG_ERROR("tox_self_set_status_message")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1216
|
|
if _libs["libtoxcore"].has("tox_self_get_status_message_size", "cdecl"):
|
|
tox_self_get_status_message_size = _libs["libtoxcore"].get("tox_self_get_status_message_size", "cdecl")
|
|
tox_self_get_status_message_size.argtypes = [POINTER(Tox)]
|
|
tox_self_get_status_message_size.restype = c_size_t
|
|
else: LOG_ERROR("tox_self_get_status_message_size")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1230
|
|
if _libs["libtoxcore"].has("tox_self_get_status_message", "cdecl"):
|
|
tox_self_get_status_message = _libs["libtoxcore"].get("tox_self_get_status_message", "cdecl")
|
|
tox_self_get_status_message.argtypes = [POINTER(Tox), POINTER(uint8_t)]
|
|
tox_self_get_status_message.restype = None
|
|
else: LOG_ERROR("tox_self_get_status_message")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1237
|
|
if _libs["libtoxcore"].has("tox_self_set_status", "cdecl"):
|
|
tox_self_set_status = _libs["libtoxcore"].get("tox_self_set_status", "cdecl")
|
|
tox_self_set_status.argtypes = [POINTER(Tox), Tox_User_Status]
|
|
tox_self_set_status.restype = None
|
|
else: LOG_ERROR("tox_self_set_status")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1242
|
|
if _libs["libtoxcore"].has("tox_self_get_status", "cdecl"):
|
|
tox_self_get_status = _libs["libtoxcore"].get("tox_self_get_status", "cdecl")
|
|
tox_self_get_status.argtypes = [POINTER(Tox)]
|
|
tox_self_get_status.restype = Tox_User_Status
|
|
else: LOG_ERROR("tox_self_get_status")
|
|
|
|
Tox_Friend_Number = uint32_t# /usr/local/src/c-toxcore/toxcore/tox.h: 1250
|
|
|
|
enum_Tox_Err_Friend_Add = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 1302
|
|
|
|
TOX_ERR_FRIEND_ADD_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 1302
|
|
|
|
TOX_ERR_FRIEND_ADD_NULL = (TOX_ERR_FRIEND_ADD_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1302
|
|
|
|
TOX_ERR_FRIEND_ADD_TOO_LONG = (TOX_ERR_FRIEND_ADD_NULL + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1302
|
|
|
|
TOX_ERR_FRIEND_ADD_NO_MESSAGE = (TOX_ERR_FRIEND_ADD_TOO_LONG + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1302
|
|
|
|
TOX_ERR_FRIEND_ADD_OWN_KEY = (TOX_ERR_FRIEND_ADD_NO_MESSAGE + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1302
|
|
|
|
TOX_ERR_FRIEND_ADD_ALREADY_SENT = (TOX_ERR_FRIEND_ADD_OWN_KEY + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1302
|
|
|
|
TOX_ERR_FRIEND_ADD_BAD_CHECKSUM = (TOX_ERR_FRIEND_ADD_ALREADY_SENT + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1302
|
|
|
|
TOX_ERR_FRIEND_ADD_SET_NEW_NOSPAM = (TOX_ERR_FRIEND_ADD_BAD_CHECKSUM + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1302
|
|
|
|
TOX_ERR_FRIEND_ADD_MALLOC = (TOX_ERR_FRIEND_ADD_SET_NEW_NOSPAM + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1302
|
|
|
|
Tox_Err_Friend_Add = enum_Tox_Err_Friend_Add# /usr/local/src/c-toxcore/toxcore/tox.h: 1302
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1304
|
|
if _libs["libtoxcore"].has("tox_err_friend_add_to_string", "cdecl"):
|
|
tox_err_friend_add_to_string = _libs["libtoxcore"].get("tox_err_friend_add_to_string", "cdecl")
|
|
tox_err_friend_add_to_string.argtypes = [Tox_Err_Friend_Add]
|
|
tox_err_friend_add_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_friend_add_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1329
|
|
if _libs["libtoxcore"].has("tox_friend_add", "cdecl"):
|
|
tox_friend_add = _libs["libtoxcore"].get("tox_friend_add", "cdecl")
|
|
tox_friend_add.argtypes = [POINTER(Tox), uint8_t * int(((32 + sizeof(uint32_t)) + sizeof(uint16_t))), POINTER(uint8_t), c_size_t, POINTER(Tox_Err_Friend_Add)]
|
|
tox_friend_add.restype = Tox_Friend_Number
|
|
else: LOG_ERROR("tox_friend_add")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1352
|
|
if _libs["libtoxcore"].has("tox_friend_add_norequest", "cdecl"):
|
|
tox_friend_add_norequest = _libs["libtoxcore"].get("tox_friend_add_norequest", "cdecl")
|
|
tox_friend_add_norequest.argtypes = [POINTER(Tox), uint8_t * int(32), POINTER(Tox_Err_Friend_Add)]
|
|
tox_friend_add_norequest.restype = Tox_Friend_Number
|
|
else: LOG_ERROR("tox_friend_add_norequest")
|
|
|
|
enum_Tox_Err_Friend_Delete = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 1367
|
|
|
|
TOX_ERR_FRIEND_DELETE_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 1367
|
|
|
|
TOX_ERR_FRIEND_DELETE_FRIEND_NOT_FOUND = (TOX_ERR_FRIEND_DELETE_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1367
|
|
|
|
Tox_Err_Friend_Delete = enum_Tox_Err_Friend_Delete# /usr/local/src/c-toxcore/toxcore/tox.h: 1367
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1369
|
|
if _libs["libtoxcore"].has("tox_err_friend_delete_to_string", "cdecl"):
|
|
tox_err_friend_delete_to_string = _libs["libtoxcore"].get("tox_err_friend_delete_to_string", "cdecl")
|
|
tox_err_friend_delete_to_string.argtypes = [Tox_Err_Friend_Delete]
|
|
tox_err_friend_delete_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_friend_delete_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1382
|
|
if _libs["libtoxcore"].has("tox_friend_delete", "cdecl"):
|
|
tox_friend_delete = _libs["libtoxcore"].get("tox_friend_delete", "cdecl")
|
|
tox_friend_delete.argtypes = [POINTER(Tox), Tox_Friend_Number, POINTER(Tox_Err_Friend_Delete)]
|
|
tox_friend_delete.restype = c_bool
|
|
else: LOG_ERROR("tox_friend_delete")
|
|
|
|
enum_Tox_Err_Friend_By_Public_Key = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 1407
|
|
|
|
TOX_ERR_FRIEND_BY_PUBLIC_KEY_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 1407
|
|
|
|
TOX_ERR_FRIEND_BY_PUBLIC_KEY_NULL = (TOX_ERR_FRIEND_BY_PUBLIC_KEY_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1407
|
|
|
|
TOX_ERR_FRIEND_BY_PUBLIC_KEY_NOT_FOUND = (TOX_ERR_FRIEND_BY_PUBLIC_KEY_NULL + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1407
|
|
|
|
Tox_Err_Friend_By_Public_Key = enum_Tox_Err_Friend_By_Public_Key# /usr/local/src/c-toxcore/toxcore/tox.h: 1407
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1409
|
|
if _libs["libtoxcore"].has("tox_err_friend_by_public_key_to_string", "cdecl"):
|
|
tox_err_friend_by_public_key_to_string = _libs["libtoxcore"].get("tox_err_friend_by_public_key_to_string", "cdecl")
|
|
tox_err_friend_by_public_key_to_string.argtypes = [Tox_Err_Friend_By_Public_Key]
|
|
tox_err_friend_by_public_key_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_friend_by_public_key_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1417
|
|
if _libs["libtoxcore"].has("tox_friend_by_public_key", "cdecl"):
|
|
tox_friend_by_public_key = _libs["libtoxcore"].get("tox_friend_by_public_key", "cdecl")
|
|
tox_friend_by_public_key.argtypes = [POINTER(Tox), uint8_t * int(32), POINTER(Tox_Err_Friend_By_Public_Key)]
|
|
tox_friend_by_public_key.restype = Tox_Friend_Number
|
|
else: LOG_ERROR("tox_friend_by_public_key")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1423
|
|
if _libs["libtoxcore"].has("tox_friend_exists", "cdecl"):
|
|
tox_friend_exists = _libs["libtoxcore"].get("tox_friend_exists", "cdecl")
|
|
tox_friend_exists.argtypes = [POINTER(Tox), Tox_Friend_Number]
|
|
tox_friend_exists.restype = c_bool
|
|
else: LOG_ERROR("tox_friend_exists")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1431
|
|
if _libs["libtoxcore"].has("tox_self_get_friend_list_size", "cdecl"):
|
|
tox_self_get_friend_list_size = _libs["libtoxcore"].get("tox_self_get_friend_list_size", "cdecl")
|
|
tox_self_get_friend_list_size.argtypes = [POINTER(Tox)]
|
|
tox_self_get_friend_list_size.restype = c_size_t
|
|
else: LOG_ERROR("tox_self_get_friend_list_size")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1441
|
|
if _libs["libtoxcore"].has("tox_self_get_friend_list", "cdecl"):
|
|
tox_self_get_friend_list = _libs["libtoxcore"].get("tox_self_get_friend_list", "cdecl")
|
|
tox_self_get_friend_list.argtypes = [POINTER(Tox), POINTER(Tox_Friend_Number)]
|
|
tox_self_get_friend_list.restype = None
|
|
else: LOG_ERROR("tox_self_get_friend_list")
|
|
|
|
enum_Tox_Err_Friend_Get_Public_Key = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 1455
|
|
|
|
TOX_ERR_FRIEND_GET_PUBLIC_KEY_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 1455
|
|
|
|
TOX_ERR_FRIEND_GET_PUBLIC_KEY_FRIEND_NOT_FOUND = (TOX_ERR_FRIEND_GET_PUBLIC_KEY_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1455
|
|
|
|
Tox_Err_Friend_Get_Public_Key = enum_Tox_Err_Friend_Get_Public_Key# /usr/local/src/c-toxcore/toxcore/tox.h: 1455
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1457
|
|
if _libs["libtoxcore"].has("tox_err_friend_get_public_key_to_string", "cdecl"):
|
|
tox_err_friend_get_public_key_to_string = _libs["libtoxcore"].get("tox_err_friend_get_public_key_to_string", "cdecl")
|
|
tox_err_friend_get_public_key_to_string.argtypes = [Tox_Err_Friend_Get_Public_Key]
|
|
tox_err_friend_get_public_key_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_friend_get_public_key_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1468
|
|
if _libs["libtoxcore"].has("tox_friend_get_public_key", "cdecl"):
|
|
tox_friend_get_public_key = _libs["libtoxcore"].get("tox_friend_get_public_key", "cdecl")
|
|
tox_friend_get_public_key.argtypes = [POINTER(Tox), Tox_Friend_Number, uint8_t * int(32), POINTER(Tox_Err_Friend_Get_Public_Key)]
|
|
tox_friend_get_public_key.restype = c_bool
|
|
else: LOG_ERROR("tox_friend_get_public_key")
|
|
|
|
enum_Tox_Err_Friend_Get_Last_Online = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 1484
|
|
|
|
TOX_ERR_FRIEND_GET_LAST_ONLINE_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 1484
|
|
|
|
TOX_ERR_FRIEND_GET_LAST_ONLINE_FRIEND_NOT_FOUND = (TOX_ERR_FRIEND_GET_LAST_ONLINE_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1484
|
|
|
|
Tox_Err_Friend_Get_Last_Online = enum_Tox_Err_Friend_Get_Last_Online# /usr/local/src/c-toxcore/toxcore/tox.h: 1484
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1486
|
|
if _libs["libtoxcore"].has("tox_err_friend_get_last_online_to_string", "cdecl"):
|
|
tox_err_friend_get_last_online_to_string = _libs["libtoxcore"].get("tox_err_friend_get_last_online_to_string", "cdecl")
|
|
tox_err_friend_get_last_online_to_string.argtypes = [Tox_Err_Friend_Get_Last_Online]
|
|
tox_err_friend_get_last_online_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_friend_get_last_online_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1496
|
|
if _libs["libtoxcore"].has("tox_friend_get_last_online", "cdecl"):
|
|
tox_friend_get_last_online = _libs["libtoxcore"].get("tox_friend_get_last_online", "cdecl")
|
|
tox_friend_get_last_online.argtypes = [POINTER(Tox), Tox_Friend_Number, POINTER(Tox_Err_Friend_Get_Last_Online)]
|
|
tox_friend_get_last_online.restype = uint64_t
|
|
else: LOG_ERROR("tox_friend_get_last_online")
|
|
|
|
enum_Tox_Err_Friend_Query = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 1527
|
|
|
|
TOX_ERR_FRIEND_QUERY_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 1527
|
|
|
|
TOX_ERR_FRIEND_QUERY_NULL = (TOX_ERR_FRIEND_QUERY_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1527
|
|
|
|
TOX_ERR_FRIEND_QUERY_FRIEND_NOT_FOUND = (TOX_ERR_FRIEND_QUERY_NULL + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1527
|
|
|
|
Tox_Err_Friend_Query = enum_Tox_Err_Friend_Query# /usr/local/src/c-toxcore/toxcore/tox.h: 1527
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1529
|
|
if _libs["libtoxcore"].has("tox_err_friend_query_to_string", "cdecl"):
|
|
tox_err_friend_query_to_string = _libs["libtoxcore"].get("tox_err_friend_query_to_string", "cdecl")
|
|
tox_err_friend_query_to_string.argtypes = [Tox_Err_Friend_Query]
|
|
tox_err_friend_query_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_friend_query_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1539
|
|
if _libs["libtoxcore"].has("tox_friend_get_name_size", "cdecl"):
|
|
tox_friend_get_name_size = _libs["libtoxcore"].get("tox_friend_get_name_size", "cdecl")
|
|
tox_friend_get_name_size.argtypes = [POINTER(Tox), Tox_Friend_Number, POINTER(Tox_Err_Friend_Query)]
|
|
tox_friend_get_name_size.restype = c_size_t
|
|
else: LOG_ERROR("tox_friend_get_name_size")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1556
|
|
if _libs["libtoxcore"].has("tox_friend_get_name", "cdecl"):
|
|
tox_friend_get_name = _libs["libtoxcore"].get("tox_friend_get_name", "cdecl")
|
|
tox_friend_get_name.argtypes = [POINTER(Tox), Tox_Friend_Number, POINTER(uint8_t), POINTER(Tox_Err_Friend_Query)]
|
|
tox_friend_get_name.restype = c_bool
|
|
else: LOG_ERROR("tox_friend_get_name")
|
|
|
|
tox_friend_name_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Friend_Number, POINTER(uint8_t), c_size_t, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 1566
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1577
|
|
if _libs["libtoxcore"].has("tox_callback_friend_name", "cdecl"):
|
|
tox_callback_friend_name = _libs["libtoxcore"].get("tox_callback_friend_name", "cdecl")
|
|
tox_callback_friend_name.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_friend_name_cb)
|
|
tox_callback_friend_name.restype = None
|
|
else: LOG_ERROR("tox_callback_friend_name")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1584
|
|
if _libs["libtoxcore"].has("tox_friend_get_status_message_size", "cdecl"):
|
|
tox_friend_get_status_message_size = _libs["libtoxcore"].get("tox_friend_get_status_message_size", "cdecl")
|
|
tox_friend_get_status_message_size.argtypes = [POINTER(Tox), Tox_Friend_Number, POINTER(Tox_Err_Friend_Query)]
|
|
tox_friend_get_status_message_size.restype = c_size_t
|
|
else: LOG_ERROR("tox_friend_get_status_message_size")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1599
|
|
if _libs["libtoxcore"].has("tox_friend_get_status_message", "cdecl"):
|
|
tox_friend_get_status_message = _libs["libtoxcore"].get("tox_friend_get_status_message", "cdecl")
|
|
tox_friend_get_status_message.argtypes = [POINTER(Tox), Tox_Friend_Number, POINTER(uint8_t), POINTER(Tox_Err_Friend_Query)]
|
|
tox_friend_get_status_message.restype = c_bool
|
|
else: LOG_ERROR("tox_friend_get_status_message")
|
|
|
|
tox_friend_status_message_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Friend_Number, POINTER(uint8_t), c_size_t, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 1611
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1622
|
|
if _libs["libtoxcore"].has("tox_callback_friend_status_message", "cdecl"):
|
|
tox_callback_friend_status_message = _libs["libtoxcore"].get("tox_callback_friend_status_message", "cdecl")
|
|
tox_callback_friend_status_message.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_friend_status_message_cb)
|
|
tox_callback_friend_status_message.restype = None
|
|
else: LOG_ERROR("tox_callback_friend_status_message")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1635
|
|
if _libs["libtoxcore"].has("tox_friend_get_status", "cdecl"):
|
|
tox_friend_get_status = _libs["libtoxcore"].get("tox_friend_get_status", "cdecl")
|
|
tox_friend_get_status.argtypes = [POINTER(Tox), Tox_Friend_Number, POINTER(Tox_Err_Friend_Query)]
|
|
tox_friend_get_status.restype = Tox_User_Status
|
|
else: LOG_ERROR("tox_friend_get_status")
|
|
|
|
tox_friend_status_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Friend_Number, Tox_User_Status, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 1643
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1653
|
|
if _libs["libtoxcore"].has("tox_callback_friend_status", "cdecl"):
|
|
tox_callback_friend_status = _libs["libtoxcore"].get("tox_callback_friend_status", "cdecl")
|
|
tox_callback_friend_status.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_friend_status_cb)
|
|
tox_callback_friend_status.restype = None
|
|
else: LOG_ERROR("tox_callback_friend_status")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1670
|
|
if _libs["libtoxcore"].has("tox_friend_get_connection_status", "cdecl"):
|
|
tox_friend_get_connection_status = _libs["libtoxcore"].get("tox_friend_get_connection_status", "cdecl")
|
|
tox_friend_get_connection_status.argtypes = [POINTER(Tox), Tox_Friend_Number, POINTER(Tox_Err_Friend_Query)]
|
|
tox_friend_get_connection_status.restype = Tox_Connection
|
|
else: LOG_ERROR("tox_friend_get_connection_status")
|
|
|
|
tox_friend_connection_status_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Friend_Number, Tox_Connection, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 1679
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1693
|
|
if _libs["libtoxcore"].has("tox_callback_friend_connection_status", "cdecl"):
|
|
tox_callback_friend_connection_status = _libs["libtoxcore"].get("tox_callback_friend_connection_status", "cdecl")
|
|
tox_callback_friend_connection_status.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_friend_connection_status_cb)
|
|
tox_callback_friend_connection_status.restype = None
|
|
else: LOG_ERROR("tox_callback_friend_connection_status")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1707
|
|
if _libs["libtoxcore"].has("tox_friend_get_typing", "cdecl"):
|
|
tox_friend_get_typing = _libs["libtoxcore"].get("tox_friend_get_typing", "cdecl")
|
|
tox_friend_get_typing.argtypes = [POINTER(Tox), Tox_Friend_Number, POINTER(Tox_Err_Friend_Query)]
|
|
tox_friend_get_typing.restype = c_bool
|
|
else: LOG_ERROR("tox_friend_get_typing")
|
|
|
|
tox_friend_typing_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Friend_Number, c_bool, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 1716
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1726
|
|
if _libs["libtoxcore"].has("tox_callback_friend_typing", "cdecl"):
|
|
tox_callback_friend_typing = _libs["libtoxcore"].get("tox_callback_friend_typing", "cdecl")
|
|
tox_callback_friend_typing.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_friend_typing_cb)
|
|
tox_callback_friend_typing.restype = None
|
|
else: LOG_ERROR("tox_callback_friend_typing")
|
|
|
|
enum_Tox_Err_Set_Typing = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 1746
|
|
|
|
TOX_ERR_SET_TYPING_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 1746
|
|
|
|
TOX_ERR_SET_TYPING_FRIEND_NOT_FOUND = (TOX_ERR_SET_TYPING_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1746
|
|
|
|
Tox_Err_Set_Typing = enum_Tox_Err_Set_Typing# /usr/local/src/c-toxcore/toxcore/tox.h: 1746
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1748
|
|
if _libs["libtoxcore"].has("tox_err_set_typing_to_string", "cdecl"):
|
|
tox_err_set_typing_to_string = _libs["libtoxcore"].get("tox_err_set_typing_to_string", "cdecl")
|
|
tox_err_set_typing_to_string.argtypes = [Tox_Err_Set_Typing]
|
|
tox_err_set_typing_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_set_typing_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1760
|
|
if _libs["libtoxcore"].has("tox_self_set_typing", "cdecl"):
|
|
tox_self_set_typing = _libs["libtoxcore"].get("tox_self_set_typing", "cdecl")
|
|
tox_self_set_typing.argtypes = [POINTER(Tox), Tox_Friend_Number, c_bool, POINTER(Tox_Err_Set_Typing)]
|
|
tox_self_set_typing.restype = c_bool
|
|
else: LOG_ERROR("tox_self_set_typing")
|
|
|
|
enum_Tox_Err_Friend_Send_Message = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 1800
|
|
|
|
TOX_ERR_FRIEND_SEND_MESSAGE_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 1800
|
|
|
|
TOX_ERR_FRIEND_SEND_MESSAGE_NULL = (TOX_ERR_FRIEND_SEND_MESSAGE_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1800
|
|
|
|
TOX_ERR_FRIEND_SEND_MESSAGE_FRIEND_NOT_FOUND = (TOX_ERR_FRIEND_SEND_MESSAGE_NULL + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1800
|
|
|
|
TOX_ERR_FRIEND_SEND_MESSAGE_FRIEND_NOT_CONNECTED = (TOX_ERR_FRIEND_SEND_MESSAGE_FRIEND_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1800
|
|
|
|
TOX_ERR_FRIEND_SEND_MESSAGE_SENDQ = (TOX_ERR_FRIEND_SEND_MESSAGE_FRIEND_NOT_CONNECTED + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1800
|
|
|
|
TOX_ERR_FRIEND_SEND_MESSAGE_TOO_LONG = (TOX_ERR_FRIEND_SEND_MESSAGE_SENDQ + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1800
|
|
|
|
TOX_ERR_FRIEND_SEND_MESSAGE_EMPTY = (TOX_ERR_FRIEND_SEND_MESSAGE_TOO_LONG + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1800
|
|
|
|
Tox_Err_Friend_Send_Message = enum_Tox_Err_Friend_Send_Message# /usr/local/src/c-toxcore/toxcore/tox.h: 1800
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1802
|
|
if _libs["libtoxcore"].has("tox_err_friend_send_message_to_string", "cdecl"):
|
|
tox_err_friend_send_message_to_string = _libs["libtoxcore"].get("tox_err_friend_send_message_to_string", "cdecl")
|
|
tox_err_friend_send_message_to_string.argtypes = [Tox_Err_Friend_Send_Message]
|
|
tox_err_friend_send_message_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_friend_send_message_to_string")
|
|
|
|
Tox_Friend_Message_Id = uint32_t# /usr/local/src/c-toxcore/toxcore/tox.h: 1804
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1829
|
|
if _libs["libtoxcore"].has("tox_friend_send_message", "cdecl"):
|
|
tox_friend_send_message = _libs["libtoxcore"].get("tox_friend_send_message", "cdecl")
|
|
tox_friend_send_message.argtypes = [POINTER(Tox), Tox_Friend_Number, Tox_Message_Type, POINTER(uint8_t), c_size_t, POINTER(Tox_Err_Friend_Send_Message)]
|
|
tox_friend_send_message.restype = Tox_Friend_Message_Id
|
|
else: LOG_ERROR("tox_friend_send_message")
|
|
|
|
tox_friend_read_receipt_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Friend_Number, Tox_Friend_Message_Id, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 1838
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1849
|
|
if _libs["libtoxcore"].has("tox_callback_friend_read_receipt", "cdecl"):
|
|
tox_callback_friend_read_receipt = _libs["libtoxcore"].get("tox_callback_friend_read_receipt", "cdecl")
|
|
tox_callback_friend_read_receipt.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_friend_read_receipt_cb)
|
|
tox_callback_friend_read_receipt.restype = None
|
|
else: LOG_ERROR("tox_callback_friend_read_receipt")
|
|
|
|
tox_friend_request_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), uint8_t * int(32), POINTER(uint8_t), c_size_t, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 1862
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1874
|
|
if _libs["libtoxcore"].has("tox_callback_friend_request", "cdecl"):
|
|
tox_callback_friend_request = _libs["libtoxcore"].get("tox_callback_friend_request", "cdecl")
|
|
tox_callback_friend_request.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_friend_request_cb)
|
|
tox_callback_friend_request.restype = None
|
|
else: LOG_ERROR("tox_callback_friend_request")
|
|
|
|
tox_friend_message_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Friend_Number, Tox_Message_Type, POINTER(uint8_t), c_size_t, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 1881
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1892
|
|
if _libs["libtoxcore"].has("tox_callback_friend_message", "cdecl"):
|
|
tox_callback_friend_message = _libs["libtoxcore"].get("tox_callback_friend_message", "cdecl")
|
|
tox_callback_friend_message.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_friend_message_cb)
|
|
tox_callback_friend_message.restype = None
|
|
else: LOG_ERROR("tox_callback_friend_message")
|
|
|
|
Tox_File_Number = uint32_t# /usr/local/src/c-toxcore/toxcore/tox.h: 1900
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1921
|
|
if _libs["libtoxcore"].has("tox_hash", "cdecl"):
|
|
tox_hash = _libs["libtoxcore"].get("tox_hash", "cdecl")
|
|
tox_hash.argtypes = [uint8_t * int(32), POINTER(uint8_t), c_size_t]
|
|
tox_hash.restype = c_bool
|
|
else: LOG_ERROR("tox_hash")
|
|
|
|
enum_Tox_File_Kind = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 1932
|
|
|
|
TOX_FILE_KIND_DATA = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 1932
|
|
|
|
TOX_FILE_KIND_AVATAR = (TOX_FILE_KIND_DATA + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1932
|
|
|
|
enum_Tox_File_Control = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 1986
|
|
|
|
TOX_FILE_CONTROL_RESUME = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 1986
|
|
|
|
TOX_FILE_CONTROL_PAUSE = (TOX_FILE_CONTROL_RESUME + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1986
|
|
|
|
TOX_FILE_CONTROL_CANCEL = (TOX_FILE_CONTROL_PAUSE + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 1986
|
|
|
|
Tox_File_Control = enum_Tox_File_Control# /usr/local/src/c-toxcore/toxcore/tox.h: 1986
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 1988
|
|
if _libs["libtoxcore"].has("tox_file_control_to_string", "cdecl"):
|
|
tox_file_control_to_string = _libs["libtoxcore"].get("tox_file_control_to_string", "cdecl")
|
|
tox_file_control_to_string.argtypes = [Tox_File_Control]
|
|
tox_file_control_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_file_control_to_string")
|
|
|
|
enum_Tox_Err_File_Control = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 2033
|
|
|
|
TOX_ERR_FILE_CONTROL_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 2033
|
|
|
|
TOX_ERR_FILE_CONTROL_FRIEND_NOT_FOUND = (TOX_ERR_FILE_CONTROL_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2033
|
|
|
|
TOX_ERR_FILE_CONTROL_FRIEND_NOT_CONNECTED = (TOX_ERR_FILE_CONTROL_FRIEND_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2033
|
|
|
|
TOX_ERR_FILE_CONTROL_NOT_FOUND = (TOX_ERR_FILE_CONTROL_FRIEND_NOT_CONNECTED + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2033
|
|
|
|
TOX_ERR_FILE_CONTROL_NOT_PAUSED = (TOX_ERR_FILE_CONTROL_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2033
|
|
|
|
TOX_ERR_FILE_CONTROL_DENIED = (TOX_ERR_FILE_CONTROL_NOT_PAUSED + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2033
|
|
|
|
TOX_ERR_FILE_CONTROL_ALREADY_PAUSED = (TOX_ERR_FILE_CONTROL_DENIED + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2033
|
|
|
|
TOX_ERR_FILE_CONTROL_SENDQ = (TOX_ERR_FILE_CONTROL_ALREADY_PAUSED + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2033
|
|
|
|
Tox_Err_File_Control = enum_Tox_Err_File_Control# /usr/local/src/c-toxcore/toxcore/tox.h: 2033
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2035
|
|
if _libs["libtoxcore"].has("tox_err_file_control_to_string", "cdecl"):
|
|
tox_err_file_control_to_string = _libs["libtoxcore"].get("tox_err_file_control_to_string", "cdecl")
|
|
tox_err_file_control_to_string.argtypes = [Tox_Err_File_Control]
|
|
tox_err_file_control_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_file_control_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2047
|
|
if _libs["libtoxcore"].has("tox_file_control", "cdecl"):
|
|
tox_file_control = _libs["libtoxcore"].get("tox_file_control", "cdecl")
|
|
tox_file_control.argtypes = [POINTER(Tox), Tox_Friend_Number, Tox_File_Number, Tox_File_Control, POINTER(Tox_Err_File_Control)]
|
|
tox_file_control.restype = c_bool
|
|
else: LOG_ERROR("tox_file_control")
|
|
|
|
tox_file_recv_control_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Friend_Number, Tox_File_Number, Tox_File_Control, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 2060
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2072
|
|
if _libs["libtoxcore"].has("tox_callback_file_recv_control", "cdecl"):
|
|
tox_callback_file_recv_control = _libs["libtoxcore"].get("tox_callback_file_recv_control", "cdecl")
|
|
tox_callback_file_recv_control.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_file_recv_control_cb)
|
|
tox_callback_file_recv_control.restype = None
|
|
else: LOG_ERROR("tox_callback_file_recv_control")
|
|
|
|
enum_Tox_Err_File_Seek = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 2111
|
|
|
|
TOX_ERR_FILE_SEEK_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 2111
|
|
|
|
TOX_ERR_FILE_SEEK_FRIEND_NOT_FOUND = (TOX_ERR_FILE_SEEK_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2111
|
|
|
|
TOX_ERR_FILE_SEEK_FRIEND_NOT_CONNECTED = (TOX_ERR_FILE_SEEK_FRIEND_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2111
|
|
|
|
TOX_ERR_FILE_SEEK_NOT_FOUND = (TOX_ERR_FILE_SEEK_FRIEND_NOT_CONNECTED + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2111
|
|
|
|
TOX_ERR_FILE_SEEK_DENIED = (TOX_ERR_FILE_SEEK_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2111
|
|
|
|
TOX_ERR_FILE_SEEK_INVALID_POSITION = (TOX_ERR_FILE_SEEK_DENIED + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2111
|
|
|
|
TOX_ERR_FILE_SEEK_SENDQ = (TOX_ERR_FILE_SEEK_INVALID_POSITION + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2111
|
|
|
|
Tox_Err_File_Seek = enum_Tox_Err_File_Seek# /usr/local/src/c-toxcore/toxcore/tox.h: 2111
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2113
|
|
if _libs["libtoxcore"].has("tox_err_file_seek_to_string", "cdecl"):
|
|
tox_err_file_seek_to_string = _libs["libtoxcore"].get("tox_err_file_seek_to_string", "cdecl")
|
|
tox_err_file_seek_to_string.argtypes = [Tox_Err_File_Seek]
|
|
tox_err_file_seek_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_file_seek_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2126
|
|
if _libs["libtoxcore"].has("tox_file_seek", "cdecl"):
|
|
tox_file_seek = _libs["libtoxcore"].get("tox_file_seek", "cdecl")
|
|
tox_file_seek.argtypes = [POINTER(Tox), Tox_Friend_Number, Tox_File_Number, uint64_t, POINTER(Tox_Err_File_Seek)]
|
|
tox_file_seek.restype = c_bool
|
|
else: LOG_ERROR("tox_file_seek")
|
|
|
|
enum_Tox_Err_File_Get = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 2151
|
|
|
|
TOX_ERR_FILE_GET_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 2151
|
|
|
|
TOX_ERR_FILE_GET_NULL = (TOX_ERR_FILE_GET_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2151
|
|
|
|
TOX_ERR_FILE_GET_FRIEND_NOT_FOUND = (TOX_ERR_FILE_GET_NULL + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2151
|
|
|
|
TOX_ERR_FILE_GET_NOT_FOUND = (TOX_ERR_FILE_GET_FRIEND_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2151
|
|
|
|
Tox_Err_File_Get = enum_Tox_Err_File_Get# /usr/local/src/c-toxcore/toxcore/tox.h: 2151
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2153
|
|
if _libs["libtoxcore"].has("tox_err_file_get_to_string", "cdecl"):
|
|
tox_err_file_get_to_string = _libs["libtoxcore"].get("tox_err_file_get_to_string", "cdecl")
|
|
tox_err_file_get_to_string.argtypes = [Tox_Err_File_Get]
|
|
tox_err_file_get_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_file_get_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2166
|
|
if _libs["libtoxcore"].has("tox_file_get_file_id", "cdecl"):
|
|
tox_file_get_file_id = _libs["libtoxcore"].get("tox_file_get_file_id", "cdecl")
|
|
tox_file_get_file_id.argtypes = [POINTER(Tox), Tox_Friend_Number, Tox_File_Number, uint8_t * int(32), POINTER(Tox_Err_File_Get)]
|
|
tox_file_get_file_id.restype = c_bool
|
|
else: LOG_ERROR("tox_file_get_file_id")
|
|
|
|
enum_Tox_Err_File_Send = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 2210
|
|
|
|
TOX_ERR_FILE_SEND_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 2210
|
|
|
|
TOX_ERR_FILE_SEND_NULL = (TOX_ERR_FILE_SEND_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2210
|
|
|
|
TOX_ERR_FILE_SEND_FRIEND_NOT_FOUND = (TOX_ERR_FILE_SEND_NULL + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2210
|
|
|
|
TOX_ERR_FILE_SEND_FRIEND_NOT_CONNECTED = (TOX_ERR_FILE_SEND_FRIEND_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2210
|
|
|
|
TOX_ERR_FILE_SEND_NAME_TOO_LONG = (TOX_ERR_FILE_SEND_FRIEND_NOT_CONNECTED + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2210
|
|
|
|
TOX_ERR_FILE_SEND_TOO_MANY = (TOX_ERR_FILE_SEND_NAME_TOO_LONG + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2210
|
|
|
|
Tox_Err_File_Send = enum_Tox_Err_File_Send# /usr/local/src/c-toxcore/toxcore/tox.h: 2210
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2212
|
|
if _libs["libtoxcore"].has("tox_err_file_send_to_string", "cdecl"):
|
|
tox_err_file_send_to_string = _libs["libtoxcore"].get("tox_err_file_send_to_string", "cdecl")
|
|
tox_err_file_send_to_string.argtypes = [Tox_Err_File_Send]
|
|
tox_err_file_send_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_file_send_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2272
|
|
if _libs["libtoxcore"].has("tox_file_send", "cdecl"):
|
|
tox_file_send = _libs["libtoxcore"].get("tox_file_send", "cdecl")
|
|
tox_file_send.argtypes = [POINTER(Tox), Tox_Friend_Number, uint32_t, uint64_t, uint8_t * int(32), POINTER(uint8_t), c_size_t, POINTER(Tox_Err_File_Send)]
|
|
tox_file_send.restype = Tox_File_Number
|
|
else: LOG_ERROR("tox_file_send")
|
|
|
|
enum_Tox_Err_File_Send_Chunk = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 2327
|
|
|
|
TOX_ERR_FILE_SEND_CHUNK_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 2327
|
|
|
|
TOX_ERR_FILE_SEND_CHUNK_NULL = (TOX_ERR_FILE_SEND_CHUNK_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2327
|
|
|
|
TOX_ERR_FILE_SEND_CHUNK_FRIEND_NOT_FOUND = (TOX_ERR_FILE_SEND_CHUNK_NULL + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2327
|
|
|
|
TOX_ERR_FILE_SEND_CHUNK_FRIEND_NOT_CONNECTED = (TOX_ERR_FILE_SEND_CHUNK_FRIEND_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2327
|
|
|
|
TOX_ERR_FILE_SEND_CHUNK_NOT_FOUND = (TOX_ERR_FILE_SEND_CHUNK_FRIEND_NOT_CONNECTED + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2327
|
|
|
|
TOX_ERR_FILE_SEND_CHUNK_NOT_TRANSFERRING = (TOX_ERR_FILE_SEND_CHUNK_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2327
|
|
|
|
TOX_ERR_FILE_SEND_CHUNK_INVALID_LENGTH = (TOX_ERR_FILE_SEND_CHUNK_NOT_TRANSFERRING + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2327
|
|
|
|
TOX_ERR_FILE_SEND_CHUNK_SENDQ = (TOX_ERR_FILE_SEND_CHUNK_INVALID_LENGTH + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2327
|
|
|
|
TOX_ERR_FILE_SEND_CHUNK_WRONG_POSITION = (TOX_ERR_FILE_SEND_CHUNK_SENDQ + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2327
|
|
|
|
Tox_Err_File_Send_Chunk = enum_Tox_Err_File_Send_Chunk# /usr/local/src/c-toxcore/toxcore/tox.h: 2327
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2329
|
|
if _libs["libtoxcore"].has("tox_err_file_send_chunk_to_string", "cdecl"):
|
|
tox_err_file_send_chunk_to_string = _libs["libtoxcore"].get("tox_err_file_send_chunk_to_string", "cdecl")
|
|
tox_err_file_send_chunk_to_string.argtypes = [Tox_Err_File_Send_Chunk]
|
|
tox_err_file_send_chunk_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_file_send_chunk_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2347
|
|
if _libs["libtoxcore"].has("tox_file_send_chunk", "cdecl"):
|
|
tox_file_send_chunk = _libs["libtoxcore"].get("tox_file_send_chunk", "cdecl")
|
|
tox_file_send_chunk.argtypes = [POINTER(Tox), Tox_Friend_Number, Tox_File_Number, uint64_t, POINTER(uint8_t), c_size_t, POINTER(Tox_Err_File_Send_Chunk)]
|
|
tox_file_send_chunk.restype = c_bool
|
|
else: LOG_ERROR("tox_file_send_chunk")
|
|
|
|
tox_file_chunk_request_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Friend_Number, Tox_File_Number, uint64_t, c_size_t, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 2373
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2384
|
|
if _libs["libtoxcore"].has("tox_callback_file_chunk_request", "cdecl"):
|
|
tox_callback_file_chunk_request = _libs["libtoxcore"].get("tox_callback_file_chunk_request", "cdecl")
|
|
tox_callback_file_chunk_request.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_file_chunk_request_cb)
|
|
tox_callback_file_chunk_request.restype = None
|
|
else: LOG_ERROR("tox_callback_file_chunk_request")
|
|
|
|
tox_file_recv_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Friend_Number, Tox_File_Number, uint32_t, uint64_t, POINTER(uint8_t), c_size_t, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 2410
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2421
|
|
if _libs["libtoxcore"].has("tox_callback_file_recv", "cdecl"):
|
|
tox_callback_file_recv = _libs["libtoxcore"].get("tox_callback_file_recv", "cdecl")
|
|
tox_callback_file_recv.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_file_recv_cb)
|
|
tox_callback_file_recv.restype = None
|
|
else: LOG_ERROR("tox_callback_file_recv")
|
|
|
|
tox_file_recv_chunk_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Friend_Number, Tox_File_Number, uint64_t, POINTER(uint8_t), c_size_t, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 2439
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2451
|
|
if _libs["libtoxcore"].has("tox_callback_file_recv_chunk", "cdecl"):
|
|
tox_callback_file_recv_chunk = _libs["libtoxcore"].get("tox_callback_file_recv_chunk", "cdecl")
|
|
tox_callback_file_recv_chunk.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_file_recv_chunk_cb)
|
|
tox_callback_file_recv_chunk.restype = None
|
|
else: LOG_ERROR("tox_callback_file_recv_chunk")
|
|
|
|
Tox_Conference_Number = uint32_t# /usr/local/src/c-toxcore/toxcore/tox.h: 2459
|
|
|
|
Tox_Conference_Peer_Number = uint32_t# /usr/local/src/c-toxcore/toxcore/tox.h: 2460
|
|
|
|
enum_Tox_Conference_Type = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 2477
|
|
|
|
TOX_CONFERENCE_TYPE_TEXT = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 2477
|
|
|
|
TOX_CONFERENCE_TYPE_AV = (TOX_CONFERENCE_TYPE_TEXT + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2477
|
|
|
|
Tox_Conference_Type = enum_Tox_Conference_Type# /usr/local/src/c-toxcore/toxcore/tox.h: 2477
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2479
|
|
if _libs["libtoxcore"].has("tox_conference_type_to_string", "cdecl"):
|
|
tox_conference_type_to_string = _libs["libtoxcore"].get("tox_conference_type_to_string", "cdecl")
|
|
tox_conference_type_to_string.argtypes = [Tox_Conference_Type]
|
|
tox_conference_type_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_conference_type_to_string")
|
|
|
|
tox_conference_invite_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Friend_Number, Tox_Conference_Type, POINTER(uint8_t), c_size_t, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 2491
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2502
|
|
if _libs["libtoxcore"].has("tox_callback_conference_invite", "cdecl"):
|
|
tox_callback_conference_invite = _libs["libtoxcore"].get("tox_callback_conference_invite", "cdecl")
|
|
tox_callback_conference_invite.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_conference_invite_cb)
|
|
tox_callback_conference_invite.restype = None
|
|
else: LOG_ERROR("tox_callback_conference_invite")
|
|
|
|
tox_conference_connected_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Conference_Number, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 2507
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2517
|
|
if _libs["libtoxcore"].has("tox_callback_conference_connected", "cdecl"):
|
|
tox_callback_conference_connected = _libs["libtoxcore"].get("tox_callback_conference_connected", "cdecl")
|
|
tox_callback_conference_connected.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_conference_connected_cb)
|
|
tox_callback_conference_connected.restype = None
|
|
else: LOG_ERROR("tox_callback_conference_connected")
|
|
|
|
tox_conference_message_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Conference_Number, Tox_Conference_Peer_Number, Tox_Message_Type, POINTER(uint8_t), c_size_t, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 2527
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2538
|
|
if _libs["libtoxcore"].has("tox_callback_conference_message", "cdecl"):
|
|
tox_callback_conference_message = _libs["libtoxcore"].get("tox_callback_conference_message", "cdecl")
|
|
tox_callback_conference_message.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_conference_message_cb)
|
|
tox_callback_conference_message.restype = None
|
|
else: LOG_ERROR("tox_callback_conference_message")
|
|
|
|
tox_conference_title_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Conference_Number, Tox_Conference_Peer_Number, POINTER(uint8_t), c_size_t, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 2547
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2560
|
|
if _libs["libtoxcore"].has("tox_callback_conference_title", "cdecl"):
|
|
tox_callback_conference_title = _libs["libtoxcore"].get("tox_callback_conference_title", "cdecl")
|
|
tox_callback_conference_title.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_conference_title_cb)
|
|
tox_callback_conference_title.restype = None
|
|
else: LOG_ERROR("tox_callback_conference_title")
|
|
|
|
tox_conference_peer_name_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Conference_Number, Tox_Conference_Peer_Number, POINTER(uint8_t), c_size_t, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 2569
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2580
|
|
if _libs["libtoxcore"].has("tox_callback_conference_peer_name", "cdecl"):
|
|
tox_callback_conference_peer_name = _libs["libtoxcore"].get("tox_callback_conference_peer_name", "cdecl")
|
|
tox_callback_conference_peer_name.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_conference_peer_name_cb)
|
|
tox_callback_conference_peer_name.restype = None
|
|
else: LOG_ERROR("tox_callback_conference_peer_name")
|
|
|
|
tox_conference_peer_list_changed_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Conference_Number, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 2586
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2595
|
|
if _libs["libtoxcore"].has("tox_callback_conference_peer_list_changed", "cdecl"):
|
|
tox_callback_conference_peer_list_changed = _libs["libtoxcore"].get("tox_callback_conference_peer_list_changed", "cdecl")
|
|
tox_callback_conference_peer_list_changed.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_conference_peer_list_changed_cb)
|
|
tox_callback_conference_peer_list_changed.restype = None
|
|
else: LOG_ERROR("tox_callback_conference_peer_list_changed")
|
|
|
|
enum_Tox_Err_Conference_New = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 2609
|
|
|
|
TOX_ERR_CONFERENCE_NEW_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 2609
|
|
|
|
TOX_ERR_CONFERENCE_NEW_INIT = (TOX_ERR_CONFERENCE_NEW_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2609
|
|
|
|
Tox_Err_Conference_New = enum_Tox_Err_Conference_New# /usr/local/src/c-toxcore/toxcore/tox.h: 2609
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2611
|
|
if _libs["libtoxcore"].has("tox_err_conference_new_to_string", "cdecl"):
|
|
tox_err_conference_new_to_string = _libs["libtoxcore"].get("tox_err_conference_new_to_string", "cdecl")
|
|
tox_err_conference_new_to_string.argtypes = [Tox_Err_Conference_New]
|
|
tox_err_conference_new_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_conference_new_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2622
|
|
if _libs["libtoxcore"].has("tox_conference_new", "cdecl"):
|
|
tox_conference_new = _libs["libtoxcore"].get("tox_conference_new", "cdecl")
|
|
tox_conference_new.argtypes = [POINTER(Tox), POINTER(Tox_Err_Conference_New)]
|
|
tox_conference_new.restype = Tox_Conference_Number
|
|
else: LOG_ERROR("tox_conference_new")
|
|
|
|
enum_Tox_Err_Conference_Delete = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 2636
|
|
|
|
TOX_ERR_CONFERENCE_DELETE_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 2636
|
|
|
|
TOX_ERR_CONFERENCE_DELETE_CONFERENCE_NOT_FOUND = (TOX_ERR_CONFERENCE_DELETE_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2636
|
|
|
|
Tox_Err_Conference_Delete = enum_Tox_Err_Conference_Delete# /usr/local/src/c-toxcore/toxcore/tox.h: 2636
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2638
|
|
if _libs["libtoxcore"].has("tox_err_conference_delete_to_string", "cdecl"):
|
|
tox_err_conference_delete_to_string = _libs["libtoxcore"].get("tox_err_conference_delete_to_string", "cdecl")
|
|
tox_err_conference_delete_to_string.argtypes = [Tox_Err_Conference_Delete]
|
|
tox_err_conference_delete_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_conference_delete_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2647
|
|
if _libs["libtoxcore"].has("tox_conference_delete", "cdecl"):
|
|
tox_conference_delete = _libs["libtoxcore"].get("tox_conference_delete", "cdecl")
|
|
tox_conference_delete.argtypes = [POINTER(Tox), Tox_Conference_Number, POINTER(Tox_Err_Conference_Delete)]
|
|
tox_conference_delete.restype = c_bool
|
|
else: LOG_ERROR("tox_conference_delete")
|
|
|
|
enum_Tox_Err_Conference_Peer_Query = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 2674
|
|
|
|
TOX_ERR_CONFERENCE_PEER_QUERY_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 2674
|
|
|
|
TOX_ERR_CONFERENCE_PEER_QUERY_CONFERENCE_NOT_FOUND = (TOX_ERR_CONFERENCE_PEER_QUERY_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2674
|
|
|
|
TOX_ERR_CONFERENCE_PEER_QUERY_PEER_NOT_FOUND = (TOX_ERR_CONFERENCE_PEER_QUERY_CONFERENCE_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2674
|
|
|
|
TOX_ERR_CONFERENCE_PEER_QUERY_NO_CONNECTION = (TOX_ERR_CONFERENCE_PEER_QUERY_PEER_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2674
|
|
|
|
Tox_Err_Conference_Peer_Query = enum_Tox_Err_Conference_Peer_Query# /usr/local/src/c-toxcore/toxcore/tox.h: 2674
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2676
|
|
if _libs["libtoxcore"].has("tox_err_conference_peer_query_to_string", "cdecl"):
|
|
tox_err_conference_peer_query_to_string = _libs["libtoxcore"].get("tox_err_conference_peer_query_to_string", "cdecl")
|
|
tox_err_conference_peer_query_to_string.argtypes = [Tox_Err_Conference_Peer_Query]
|
|
tox_err_conference_peer_query_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_conference_peer_query_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2685
|
|
if _libs["libtoxcore"].has("tox_conference_peer_count", "cdecl"):
|
|
tox_conference_peer_count = _libs["libtoxcore"].get("tox_conference_peer_count", "cdecl")
|
|
tox_conference_peer_count.argtypes = [POINTER(Tox), Tox_Conference_Number, POINTER(Tox_Err_Conference_Peer_Query)]
|
|
tox_conference_peer_count.restype = Tox_Conference_Peer_Number
|
|
else: LOG_ERROR("tox_conference_peer_count")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2693
|
|
if _libs["libtoxcore"].has("tox_conference_peer_get_name_size", "cdecl"):
|
|
tox_conference_peer_get_name_size = _libs["libtoxcore"].get("tox_conference_peer_get_name_size", "cdecl")
|
|
tox_conference_peer_get_name_size.argtypes = [POINTER(Tox), Tox_Conference_Number, Tox_Conference_Peer_Number, POINTER(Tox_Err_Conference_Peer_Query)]
|
|
tox_conference_peer_get_name_size.restype = c_size_t
|
|
else: LOG_ERROR("tox_conference_peer_get_name_size")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2706
|
|
if _libs["libtoxcore"].has("tox_conference_peer_get_name", "cdecl"):
|
|
tox_conference_peer_get_name = _libs["libtoxcore"].get("tox_conference_peer_get_name", "cdecl")
|
|
tox_conference_peer_get_name.argtypes = [POINTER(Tox), Tox_Conference_Number, Tox_Conference_Peer_Number, POINTER(uint8_t), POINTER(Tox_Err_Conference_Peer_Query)]
|
|
tox_conference_peer_get_name.restype = c_bool
|
|
else: LOG_ERROR("tox_conference_peer_get_name")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2717
|
|
if _libs["libtoxcore"].has("tox_conference_peer_get_public_key", "cdecl"):
|
|
tox_conference_peer_get_public_key = _libs["libtoxcore"].get("tox_conference_peer_get_public_key", "cdecl")
|
|
tox_conference_peer_get_public_key.argtypes = [POINTER(Tox), Tox_Conference_Number, Tox_Conference_Peer_Number, uint8_t * int(32), POINTER(Tox_Err_Conference_Peer_Query)]
|
|
tox_conference_peer_get_public_key.restype = c_bool
|
|
else: LOG_ERROR("tox_conference_peer_get_public_key")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2724
|
|
if _libs["libtoxcore"].has("tox_conference_peer_number_is_ours", "cdecl"):
|
|
tox_conference_peer_number_is_ours = _libs["libtoxcore"].get("tox_conference_peer_number_is_ours", "cdecl")
|
|
tox_conference_peer_number_is_ours.argtypes = [POINTER(Tox), Tox_Conference_Number, Tox_Conference_Peer_Number, POINTER(Tox_Err_Conference_Peer_Query)]
|
|
tox_conference_peer_number_is_ours.restype = c_bool
|
|
else: LOG_ERROR("tox_conference_peer_number_is_ours")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2736
|
|
if _libs["libtoxcore"].has("tox_conference_offline_peer_count", "cdecl"):
|
|
tox_conference_offline_peer_count = _libs["libtoxcore"].get("tox_conference_offline_peer_count", "cdecl")
|
|
tox_conference_offline_peer_count.argtypes = [POINTER(Tox), Tox_Conference_Number, POINTER(Tox_Err_Conference_Peer_Query)]
|
|
tox_conference_offline_peer_count.restype = uint32_t
|
|
else: LOG_ERROR("tox_conference_offline_peer_count")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2745
|
|
if _libs["libtoxcore"].has("tox_conference_offline_peer_get_name_size", "cdecl"):
|
|
tox_conference_offline_peer_get_name_size = _libs["libtoxcore"].get("tox_conference_offline_peer_get_name_size", "cdecl")
|
|
tox_conference_offline_peer_get_name_size.argtypes = [POINTER(Tox), Tox_Conference_Number, Tox_Conference_Peer_Number, POINTER(Tox_Err_Conference_Peer_Query)]
|
|
tox_conference_offline_peer_get_name_size.restype = c_size_t
|
|
else: LOG_ERROR("tox_conference_offline_peer_get_name_size")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2759
|
|
if _libs["libtoxcore"].has("tox_conference_offline_peer_get_name", "cdecl"):
|
|
tox_conference_offline_peer_get_name = _libs["libtoxcore"].get("tox_conference_offline_peer_get_name", "cdecl")
|
|
tox_conference_offline_peer_get_name.argtypes = [POINTER(Tox), Tox_Conference_Number, Tox_Conference_Peer_Number, POINTER(uint8_t), POINTER(Tox_Err_Conference_Peer_Query)]
|
|
tox_conference_offline_peer_get_name.restype = c_bool
|
|
else: LOG_ERROR("tox_conference_offline_peer_get_name")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2770
|
|
if _libs["libtoxcore"].has("tox_conference_offline_peer_get_public_key", "cdecl"):
|
|
tox_conference_offline_peer_get_public_key = _libs["libtoxcore"].get("tox_conference_offline_peer_get_public_key", "cdecl")
|
|
tox_conference_offline_peer_get_public_key.argtypes = [POINTER(Tox), Tox_Conference_Number, Tox_Conference_Peer_Number, uint8_t * int(32), POINTER(Tox_Err_Conference_Peer_Query)]
|
|
tox_conference_offline_peer_get_public_key.restype = c_bool
|
|
else: LOG_ERROR("tox_conference_offline_peer_get_public_key")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2777
|
|
if _libs["libtoxcore"].has("tox_conference_offline_peer_get_last_active", "cdecl"):
|
|
tox_conference_offline_peer_get_last_active = _libs["libtoxcore"].get("tox_conference_offline_peer_get_last_active", "cdecl")
|
|
tox_conference_offline_peer_get_last_active.argtypes = [POINTER(Tox), Tox_Conference_Number, Tox_Conference_Peer_Number, POINTER(Tox_Err_Conference_Peer_Query)]
|
|
tox_conference_offline_peer_get_last_active.restype = uint64_t
|
|
else: LOG_ERROR("tox_conference_offline_peer_get_last_active")
|
|
|
|
enum_Tox_Err_Conference_Set_Max_Offline = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 2793
|
|
|
|
TOX_ERR_CONFERENCE_SET_MAX_OFFLINE_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 2793
|
|
|
|
TOX_ERR_CONFERENCE_SET_MAX_OFFLINE_CONFERENCE_NOT_FOUND = (TOX_ERR_CONFERENCE_SET_MAX_OFFLINE_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2793
|
|
|
|
Tox_Err_Conference_Set_Max_Offline = enum_Tox_Err_Conference_Set_Max_Offline# /usr/local/src/c-toxcore/toxcore/tox.h: 2793
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2795
|
|
if _libs["libtoxcore"].has("tox_err_conference_set_max_offline_to_string", "cdecl"):
|
|
tox_err_conference_set_max_offline_to_string = _libs["libtoxcore"].get("tox_err_conference_set_max_offline_to_string", "cdecl")
|
|
tox_err_conference_set_max_offline_to_string.argtypes = [Tox_Err_Conference_Set_Max_Offline]
|
|
tox_err_conference_set_max_offline_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_conference_set_max_offline_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2800
|
|
if _libs["libtoxcore"].has("tox_conference_set_max_offline", "cdecl"):
|
|
tox_conference_set_max_offline = _libs["libtoxcore"].get("tox_conference_set_max_offline", "cdecl")
|
|
tox_conference_set_max_offline.argtypes = [POINTER(Tox), Tox_Conference_Number, uint32_t, POINTER(Tox_Err_Conference_Set_Max_Offline)]
|
|
tox_conference_set_max_offline.restype = c_bool
|
|
else: LOG_ERROR("tox_conference_set_max_offline")
|
|
|
|
enum_Tox_Err_Conference_Invite = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 2826
|
|
|
|
TOX_ERR_CONFERENCE_INVITE_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 2826
|
|
|
|
TOX_ERR_CONFERENCE_INVITE_CONFERENCE_NOT_FOUND = (TOX_ERR_CONFERENCE_INVITE_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2826
|
|
|
|
TOX_ERR_CONFERENCE_INVITE_FAIL_SEND = (TOX_ERR_CONFERENCE_INVITE_CONFERENCE_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2826
|
|
|
|
TOX_ERR_CONFERENCE_INVITE_NO_CONNECTION = (TOX_ERR_CONFERENCE_INVITE_FAIL_SEND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2826
|
|
|
|
Tox_Err_Conference_Invite = enum_Tox_Err_Conference_Invite# /usr/local/src/c-toxcore/toxcore/tox.h: 2826
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2828
|
|
if _libs["libtoxcore"].has("tox_err_conference_invite_to_string", "cdecl"):
|
|
tox_err_conference_invite_to_string = _libs["libtoxcore"].get("tox_err_conference_invite_to_string", "cdecl")
|
|
tox_err_conference_invite_to_string.argtypes = [Tox_Err_Conference_Invite]
|
|
tox_err_conference_invite_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_conference_invite_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2838
|
|
if _libs["libtoxcore"].has("tox_conference_invite", "cdecl"):
|
|
tox_conference_invite = _libs["libtoxcore"].get("tox_conference_invite", "cdecl")
|
|
tox_conference_invite.argtypes = [POINTER(Tox), Tox_Friend_Number, Tox_Conference_Number, POINTER(Tox_Err_Conference_Invite)]
|
|
tox_conference_invite.restype = c_bool
|
|
else: LOG_ERROR("tox_conference_invite")
|
|
|
|
enum_Tox_Err_Conference_Join = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 2879
|
|
|
|
TOX_ERR_CONFERENCE_JOIN_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 2879
|
|
|
|
TOX_ERR_CONFERENCE_JOIN_INVALID_LENGTH = (TOX_ERR_CONFERENCE_JOIN_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2879
|
|
|
|
TOX_ERR_CONFERENCE_JOIN_WRONG_TYPE = (TOX_ERR_CONFERENCE_JOIN_INVALID_LENGTH + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2879
|
|
|
|
TOX_ERR_CONFERENCE_JOIN_FRIEND_NOT_FOUND = (TOX_ERR_CONFERENCE_JOIN_WRONG_TYPE + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2879
|
|
|
|
TOX_ERR_CONFERENCE_JOIN_DUPLICATE = (TOX_ERR_CONFERENCE_JOIN_FRIEND_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2879
|
|
|
|
TOX_ERR_CONFERENCE_JOIN_INIT_FAIL = (TOX_ERR_CONFERENCE_JOIN_DUPLICATE + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2879
|
|
|
|
TOX_ERR_CONFERENCE_JOIN_FAIL_SEND = (TOX_ERR_CONFERENCE_JOIN_INIT_FAIL + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2879
|
|
|
|
Tox_Err_Conference_Join = enum_Tox_Err_Conference_Join# /usr/local/src/c-toxcore/toxcore/tox.h: 2879
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2881
|
|
if _libs["libtoxcore"].has("tox_err_conference_join_to_string", "cdecl"):
|
|
tox_err_conference_join_to_string = _libs["libtoxcore"].get("tox_err_conference_join_to_string", "cdecl")
|
|
tox_err_conference_join_to_string.argtypes = [Tox_Err_Conference_Join]
|
|
tox_err_conference_join_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_conference_join_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2900
|
|
if _libs["libtoxcore"].has("tox_conference_join", "cdecl"):
|
|
tox_conference_join = _libs["libtoxcore"].get("tox_conference_join", "cdecl")
|
|
tox_conference_join.argtypes = [POINTER(Tox), Tox_Friend_Number, POINTER(uint8_t), c_size_t, POINTER(Tox_Err_Conference_Join)]
|
|
tox_conference_join.restype = Tox_Conference_Number
|
|
else: LOG_ERROR("tox_conference_join")
|
|
|
|
enum_Tox_Err_Conference_Send_Message = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 2932
|
|
|
|
TOX_ERR_CONFERENCE_SEND_MESSAGE_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 2932
|
|
|
|
TOX_ERR_CONFERENCE_SEND_MESSAGE_CONFERENCE_NOT_FOUND = (TOX_ERR_CONFERENCE_SEND_MESSAGE_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2932
|
|
|
|
TOX_ERR_CONFERENCE_SEND_MESSAGE_TOO_LONG = (TOX_ERR_CONFERENCE_SEND_MESSAGE_CONFERENCE_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2932
|
|
|
|
TOX_ERR_CONFERENCE_SEND_MESSAGE_NO_CONNECTION = (TOX_ERR_CONFERENCE_SEND_MESSAGE_TOO_LONG + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2932
|
|
|
|
TOX_ERR_CONFERENCE_SEND_MESSAGE_FAIL_SEND = (TOX_ERR_CONFERENCE_SEND_MESSAGE_NO_CONNECTION + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2932
|
|
|
|
Tox_Err_Conference_Send_Message = enum_Tox_Err_Conference_Send_Message# /usr/local/src/c-toxcore/toxcore/tox.h: 2932
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2934
|
|
if _libs["libtoxcore"].has("tox_err_conference_send_message_to_string", "cdecl"):
|
|
tox_err_conference_send_message_to_string = _libs["libtoxcore"].get("tox_err_conference_send_message_to_string", "cdecl")
|
|
tox_err_conference_send_message_to_string.argtypes = [Tox_Err_Conference_Send_Message]
|
|
tox_err_conference_send_message_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_conference_send_message_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2955
|
|
if _libs["libtoxcore"].has("tox_conference_send_message", "cdecl"):
|
|
tox_conference_send_message = _libs["libtoxcore"].get("tox_conference_send_message", "cdecl")
|
|
tox_conference_send_message.argtypes = [POINTER(Tox), Tox_Conference_Number, Tox_Message_Type, POINTER(uint8_t), c_size_t, POINTER(Tox_Err_Conference_Send_Message)]
|
|
tox_conference_send_message.restype = c_bool
|
|
else: LOG_ERROR("tox_conference_send_message")
|
|
|
|
enum_Tox_Err_Conference_Title = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 2982
|
|
|
|
TOX_ERR_CONFERENCE_TITLE_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 2982
|
|
|
|
TOX_ERR_CONFERENCE_TITLE_CONFERENCE_NOT_FOUND = (TOX_ERR_CONFERENCE_TITLE_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2982
|
|
|
|
TOX_ERR_CONFERENCE_TITLE_INVALID_LENGTH = (TOX_ERR_CONFERENCE_TITLE_CONFERENCE_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2982
|
|
|
|
TOX_ERR_CONFERENCE_TITLE_FAIL_SEND = (TOX_ERR_CONFERENCE_TITLE_INVALID_LENGTH + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 2982
|
|
|
|
Tox_Err_Conference_Title = enum_Tox_Err_Conference_Title# /usr/local/src/c-toxcore/toxcore/tox.h: 2982
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2984
|
|
if _libs["libtoxcore"].has("tox_err_conference_title_to_string", "cdecl"):
|
|
tox_err_conference_title_to_string = _libs["libtoxcore"].get("tox_err_conference_title_to_string", "cdecl")
|
|
tox_err_conference_title_to_string.argtypes = [Tox_Err_Conference_Title]
|
|
tox_err_conference_title_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_conference_title_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 2994
|
|
if _libs["libtoxcore"].has("tox_conference_get_title_size", "cdecl"):
|
|
tox_conference_get_title_size = _libs["libtoxcore"].get("tox_conference_get_title_size", "cdecl")
|
|
tox_conference_get_title_size.argtypes = [POINTER(Tox), Tox_Conference_Number, POINTER(Tox_Err_Conference_Title)]
|
|
tox_conference_get_title_size.restype = c_size_t
|
|
else: LOG_ERROR("tox_conference_get_title_size")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3010
|
|
if _libs["libtoxcore"].has("tox_conference_get_title", "cdecl"):
|
|
tox_conference_get_title = _libs["libtoxcore"].get("tox_conference_get_title", "cdecl")
|
|
tox_conference_get_title.argtypes = [POINTER(Tox), Tox_Conference_Number, POINTER(uint8_t), POINTER(Tox_Err_Conference_Title)]
|
|
tox_conference_get_title.restype = c_bool
|
|
else: LOG_ERROR("tox_conference_get_title")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3022
|
|
if _libs["libtoxcore"].has("tox_conference_set_title", "cdecl"):
|
|
tox_conference_set_title = _libs["libtoxcore"].get("tox_conference_set_title", "cdecl")
|
|
tox_conference_set_title.argtypes = [POINTER(Tox), Tox_Conference_Number, POINTER(uint8_t), c_size_t, POINTER(Tox_Err_Conference_Title)]
|
|
tox_conference_set_title.restype = c_bool
|
|
else: LOG_ERROR("tox_conference_set_title")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3032
|
|
if _libs["libtoxcore"].has("tox_conference_get_chatlist_size", "cdecl"):
|
|
tox_conference_get_chatlist_size = _libs["libtoxcore"].get("tox_conference_get_chatlist_size", "cdecl")
|
|
tox_conference_get_chatlist_size.argtypes = [POINTER(Tox)]
|
|
tox_conference_get_chatlist_size.restype = c_size_t
|
|
else: LOG_ERROR("tox_conference_get_chatlist_size")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3048
|
|
if _libs["libtoxcore"].has("tox_conference_get_chatlist", "cdecl"):
|
|
tox_conference_get_chatlist = _libs["libtoxcore"].get("tox_conference_get_chatlist", "cdecl")
|
|
tox_conference_get_chatlist.argtypes = [POINTER(Tox), POINTER(Tox_Conference_Number)]
|
|
tox_conference_get_chatlist.restype = None
|
|
else: LOG_ERROR("tox_conference_get_chatlist")
|
|
|
|
enum_Tox_Err_Conference_Get_Type = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 3067
|
|
|
|
TOX_ERR_CONFERENCE_GET_TYPE_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 3067
|
|
|
|
TOX_ERR_CONFERENCE_GET_TYPE_CONFERENCE_NOT_FOUND = (TOX_ERR_CONFERENCE_GET_TYPE_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3067
|
|
|
|
Tox_Err_Conference_Get_Type = enum_Tox_Err_Conference_Get_Type# /usr/local/src/c-toxcore/toxcore/tox.h: 3067
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3069
|
|
if _libs["libtoxcore"].has("tox_err_conference_get_type_to_string", "cdecl"):
|
|
tox_err_conference_get_type_to_string = _libs["libtoxcore"].get("tox_err_conference_get_type_to_string", "cdecl")
|
|
tox_err_conference_get_type_to_string.argtypes = [Tox_Err_Conference_Get_Type]
|
|
tox_err_conference_get_type_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_conference_get_type_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3074
|
|
if _libs["libtoxcore"].has("tox_conference_get_type", "cdecl"):
|
|
tox_conference_get_type = _libs["libtoxcore"].get("tox_conference_get_type", "cdecl")
|
|
tox_conference_get_type.argtypes = [POINTER(Tox), Tox_Conference_Number, POINTER(Tox_Err_Conference_Get_Type)]
|
|
tox_conference_get_type.restype = Tox_Conference_Type
|
|
else: LOG_ERROR("tox_conference_get_type")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3087
|
|
if _libs["libtoxcore"].has("tox_conference_get_id", "cdecl"):
|
|
tox_conference_get_id = _libs["libtoxcore"].get("tox_conference_get_id", "cdecl")
|
|
tox_conference_get_id.argtypes = [POINTER(Tox), Tox_Conference_Number, uint8_t * int(32)]
|
|
tox_conference_get_id.restype = c_bool
|
|
else: LOG_ERROR("tox_conference_get_id")
|
|
|
|
enum_Tox_Err_Conference_By_Id = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 3107
|
|
|
|
TOX_ERR_CONFERENCE_BY_ID_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 3107
|
|
|
|
TOX_ERR_CONFERENCE_BY_ID_NULL = (TOX_ERR_CONFERENCE_BY_ID_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3107
|
|
|
|
TOX_ERR_CONFERENCE_BY_ID_NOT_FOUND = (TOX_ERR_CONFERENCE_BY_ID_NULL + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3107
|
|
|
|
Tox_Err_Conference_By_Id = enum_Tox_Err_Conference_By_Id# /usr/local/src/c-toxcore/toxcore/tox.h: 3107
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3109
|
|
if _libs["libtoxcore"].has("tox_err_conference_by_id_to_string", "cdecl"):
|
|
tox_err_conference_by_id_to_string = _libs["libtoxcore"].get("tox_err_conference_by_id_to_string", "cdecl")
|
|
tox_err_conference_by_id_to_string.argtypes = [Tox_Err_Conference_By_Id]
|
|
tox_err_conference_by_id_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_conference_by_id_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3118
|
|
if _libs["libtoxcore"].has("tox_conference_by_id", "cdecl"):
|
|
tox_conference_by_id = _libs["libtoxcore"].get("tox_conference_by_id", "cdecl")
|
|
tox_conference_by_id.argtypes = [POINTER(Tox), uint8_t * int(32), POINTER(Tox_Err_Conference_By_Id)]
|
|
tox_conference_by_id.restype = Tox_Conference_Number
|
|
else: LOG_ERROR("tox_conference_by_id")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3131
|
|
if _libs["libtoxcore"].has("tox_conference_get_uid", "cdecl"):
|
|
tox_conference_get_uid = _libs["libtoxcore"].get("tox_conference_get_uid", "cdecl")
|
|
tox_conference_get_uid.argtypes = [POINTER(Tox), Tox_Conference_Number, uint8_t * int(32)]
|
|
tox_conference_get_uid.restype = c_bool
|
|
else: LOG_ERROR("tox_conference_get_uid")
|
|
|
|
enum_Tox_Err_Conference_By_Uid = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 3151
|
|
|
|
TOX_ERR_CONFERENCE_BY_UID_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 3151
|
|
|
|
TOX_ERR_CONFERENCE_BY_UID_NULL = (TOX_ERR_CONFERENCE_BY_UID_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3151
|
|
|
|
TOX_ERR_CONFERENCE_BY_UID_NOT_FOUND = (TOX_ERR_CONFERENCE_BY_UID_NULL + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3151
|
|
|
|
Tox_Err_Conference_By_Uid = enum_Tox_Err_Conference_By_Uid# /usr/local/src/c-toxcore/toxcore/tox.h: 3151
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3153
|
|
if _libs["libtoxcore"].has("tox_err_conference_by_uid_to_string", "cdecl"):
|
|
tox_err_conference_by_uid_to_string = _libs["libtoxcore"].get("tox_err_conference_by_uid_to_string", "cdecl")
|
|
tox_err_conference_by_uid_to_string.argtypes = [Tox_Err_Conference_By_Uid]
|
|
tox_err_conference_by_uid_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_conference_by_uid_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3163
|
|
if _libs["libtoxcore"].has("tox_conference_by_uid", "cdecl"):
|
|
tox_conference_by_uid = _libs["libtoxcore"].get("tox_conference_by_uid", "cdecl")
|
|
tox_conference_by_uid.argtypes = [POINTER(Tox), uint8_t * int(32), POINTER(Tox_Err_Conference_By_Uid)]
|
|
tox_conference_by_uid.restype = Tox_Conference_Number
|
|
else: LOG_ERROR("tox_conference_by_uid")
|
|
|
|
enum_Tox_Err_Friend_Custom_Packet = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 3215
|
|
|
|
TOX_ERR_FRIEND_CUSTOM_PACKET_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 3215
|
|
|
|
TOX_ERR_FRIEND_CUSTOM_PACKET_NULL = (TOX_ERR_FRIEND_CUSTOM_PACKET_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3215
|
|
|
|
TOX_ERR_FRIEND_CUSTOM_PACKET_FRIEND_NOT_FOUND = (TOX_ERR_FRIEND_CUSTOM_PACKET_NULL + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3215
|
|
|
|
TOX_ERR_FRIEND_CUSTOM_PACKET_FRIEND_NOT_CONNECTED = (TOX_ERR_FRIEND_CUSTOM_PACKET_FRIEND_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3215
|
|
|
|
TOX_ERR_FRIEND_CUSTOM_PACKET_INVALID = (TOX_ERR_FRIEND_CUSTOM_PACKET_FRIEND_NOT_CONNECTED + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3215
|
|
|
|
TOX_ERR_FRIEND_CUSTOM_PACKET_EMPTY = (TOX_ERR_FRIEND_CUSTOM_PACKET_INVALID + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3215
|
|
|
|
TOX_ERR_FRIEND_CUSTOM_PACKET_TOO_LONG = (TOX_ERR_FRIEND_CUSTOM_PACKET_EMPTY + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3215
|
|
|
|
TOX_ERR_FRIEND_CUSTOM_PACKET_SENDQ = (TOX_ERR_FRIEND_CUSTOM_PACKET_TOO_LONG + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3215
|
|
|
|
Tox_Err_Friend_Custom_Packet = enum_Tox_Err_Friend_Custom_Packet# /usr/local/src/c-toxcore/toxcore/tox.h: 3215
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3217
|
|
if _libs["libtoxcore"].has("tox_err_friend_custom_packet_to_string", "cdecl"):
|
|
tox_err_friend_custom_packet_to_string = _libs["libtoxcore"].get("tox_err_friend_custom_packet_to_string", "cdecl")
|
|
tox_err_friend_custom_packet_to_string.argtypes = [Tox_Err_Friend_Custom_Packet]
|
|
tox_err_friend_custom_packet_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_friend_custom_packet_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3239
|
|
if _libs["libtoxcore"].has("tox_friend_send_lossy_packet", "cdecl"):
|
|
tox_friend_send_lossy_packet = _libs["libtoxcore"].get("tox_friend_send_lossy_packet", "cdecl")
|
|
tox_friend_send_lossy_packet.argtypes = [POINTER(Tox), Tox_Friend_Number, POINTER(uint8_t), c_size_t, POINTER(Tox_Err_Friend_Custom_Packet)]
|
|
tox_friend_send_lossy_packet.restype = c_bool
|
|
else: LOG_ERROR("tox_friend_send_lossy_packet")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3260
|
|
if _libs["libtoxcore"].has("tox_friend_send_lossless_packet", "cdecl"):
|
|
tox_friend_send_lossless_packet = _libs["libtoxcore"].get("tox_friend_send_lossless_packet", "cdecl")
|
|
tox_friend_send_lossless_packet.argtypes = [POINTER(Tox), Tox_Friend_Number, POINTER(uint8_t), c_size_t, POINTER(Tox_Err_Friend_Custom_Packet)]
|
|
tox_friend_send_lossless_packet.restype = c_bool
|
|
else: LOG_ERROR("tox_friend_send_lossless_packet")
|
|
|
|
tox_friend_lossy_packet_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Friend_Number, POINTER(uint8_t), c_size_t, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 3270
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3280
|
|
if _libs["libtoxcore"].has("tox_callback_friend_lossy_packet", "cdecl"):
|
|
tox_callback_friend_lossy_packet = _libs["libtoxcore"].get("tox_callback_friend_lossy_packet", "cdecl")
|
|
tox_callback_friend_lossy_packet.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_friend_lossy_packet_cb)
|
|
tox_callback_friend_lossy_packet.restype = None
|
|
else: LOG_ERROR("tox_callback_friend_lossy_packet")
|
|
|
|
tox_friend_lossless_packet_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Friend_Number, POINTER(uint8_t), c_size_t, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 3287
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3297
|
|
if _libs["libtoxcore"].has("tox_callback_friend_lossless_packet", "cdecl"):
|
|
tox_callback_friend_lossless_packet = _libs["libtoxcore"].get("tox_callback_friend_lossless_packet", "cdecl")
|
|
tox_callback_friend_lossless_packet.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_friend_lossless_packet_cb)
|
|
tox_callback_friend_lossless_packet.restype = None
|
|
else: LOG_ERROR("tox_callback_friend_lossless_packet")
|
|
|
|
enum_Tox_Err_Get_Port = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 3317
|
|
|
|
TOX_ERR_GET_PORT_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 3317
|
|
|
|
TOX_ERR_GET_PORT_NOT_BOUND = (TOX_ERR_GET_PORT_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3317
|
|
|
|
Tox_Err_Get_Port = enum_Tox_Err_Get_Port# /usr/local/src/c-toxcore/toxcore/tox.h: 3317
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3319
|
|
if _libs["libtoxcore"].has("tox_err_get_port_to_string", "cdecl"):
|
|
tox_err_get_port_to_string = _libs["libtoxcore"].get("tox_err_get_port_to_string", "cdecl")
|
|
tox_err_get_port_to_string.argtypes = [Tox_Err_Get_Port]
|
|
tox_err_get_port_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_get_port_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3333
|
|
if _libs["libtoxcore"].has("tox_self_get_dht_id", "cdecl"):
|
|
tox_self_get_dht_id = _libs["libtoxcore"].get("tox_self_get_dht_id", "cdecl")
|
|
tox_self_get_dht_id.argtypes = [POINTER(Tox), uint8_t * int(32)]
|
|
tox_self_get_dht_id.restype = None
|
|
else: LOG_ERROR("tox_self_get_dht_id")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3338
|
|
if _libs["libtoxcore"].has("tox_self_get_udp_port", "cdecl"):
|
|
tox_self_get_udp_port = _libs["libtoxcore"].get("tox_self_get_udp_port", "cdecl")
|
|
tox_self_get_udp_port.argtypes = [POINTER(Tox), POINTER(Tox_Err_Get_Port)]
|
|
tox_self_get_udp_port.restype = uint16_t
|
|
else: LOG_ERROR("tox_self_get_udp_port")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3345
|
|
if _libs["libtoxcore"].has("tox_self_get_tcp_port", "cdecl"):
|
|
tox_self_get_tcp_port = _libs["libtoxcore"].get("tox_self_get_tcp_port", "cdecl")
|
|
tox_self_get_tcp_port.argtypes = [POINTER(Tox), POINTER(Tox_Err_Get_Port)]
|
|
tox_self_get_tcp_port.restype = uint16_t
|
|
else: LOG_ERROR("tox_self_get_tcp_port")
|
|
|
|
Tox_Group_Number = uint32_t# /usr/local/src/c-toxcore/toxcore/tox.h: 3353
|
|
|
|
Tox_Group_Peer_Number = uint32_t# /usr/local/src/c-toxcore/toxcore/tox.h: 3354
|
|
|
|
Tox_Group_Message_Id = uint32_t# /usr/local/src/c-toxcore/toxcore/tox.h: 3355
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3368
|
|
if _libs["libtoxcore"].has("tox_group_max_topic_length", "cdecl"):
|
|
tox_group_max_topic_length = _libs["libtoxcore"].get("tox_group_max_topic_length", "cdecl")
|
|
tox_group_max_topic_length.argtypes = []
|
|
tox_group_max_topic_length.restype = uint32_t
|
|
else: LOG_ERROR("tox_group_max_topic_length")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3375
|
|
if _libs["libtoxcore"].has("tox_group_max_part_length", "cdecl"):
|
|
tox_group_max_part_length = _libs["libtoxcore"].get("tox_group_max_part_length", "cdecl")
|
|
tox_group_max_part_length.argtypes = []
|
|
tox_group_max_part_length.restype = uint32_t
|
|
else: LOG_ERROR("tox_group_max_part_length")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3382
|
|
if _libs["libtoxcore"].has("tox_group_max_message_length", "cdecl"):
|
|
tox_group_max_message_length = _libs["libtoxcore"].get("tox_group_max_message_length", "cdecl")
|
|
tox_group_max_message_length.argtypes = []
|
|
tox_group_max_message_length.restype = uint32_t
|
|
else: LOG_ERROR("tox_group_max_message_length")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3389
|
|
if _libs["libtoxcore"].has("tox_group_max_custom_lossy_packet_length", "cdecl"):
|
|
tox_group_max_custom_lossy_packet_length = _libs["libtoxcore"].get("tox_group_max_custom_lossy_packet_length", "cdecl")
|
|
tox_group_max_custom_lossy_packet_length.argtypes = []
|
|
tox_group_max_custom_lossy_packet_length.restype = uint32_t
|
|
else: LOG_ERROR("tox_group_max_custom_lossy_packet_length")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3396
|
|
if _libs["libtoxcore"].has("tox_group_max_custom_lossless_packet_length", "cdecl"):
|
|
tox_group_max_custom_lossless_packet_length = _libs["libtoxcore"].get("tox_group_max_custom_lossless_packet_length", "cdecl")
|
|
tox_group_max_custom_lossless_packet_length.argtypes = []
|
|
tox_group_max_custom_lossless_packet_length.restype = uint32_t
|
|
else: LOG_ERROR("tox_group_max_custom_lossless_packet_length")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3403
|
|
if _libs["libtoxcore"].has("tox_group_max_group_name_length", "cdecl"):
|
|
tox_group_max_group_name_length = _libs["libtoxcore"].get("tox_group_max_group_name_length", "cdecl")
|
|
tox_group_max_group_name_length.argtypes = []
|
|
tox_group_max_group_name_length.restype = uint32_t
|
|
else: LOG_ERROR("tox_group_max_group_name_length")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3410
|
|
if _libs["libtoxcore"].has("tox_group_max_password_size", "cdecl"):
|
|
tox_group_max_password_size = _libs["libtoxcore"].get("tox_group_max_password_size", "cdecl")
|
|
tox_group_max_password_size.argtypes = []
|
|
tox_group_max_password_size.restype = uint32_t
|
|
else: LOG_ERROR("tox_group_max_password_size")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3417
|
|
if _libs["libtoxcore"].has("tox_group_chat_id_size", "cdecl"):
|
|
tox_group_chat_id_size = _libs["libtoxcore"].get("tox_group_chat_id_size", "cdecl")
|
|
tox_group_chat_id_size.argtypes = []
|
|
tox_group_chat_id_size.restype = uint32_t
|
|
else: LOG_ERROR("tox_group_chat_id_size")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3424
|
|
if _libs["libtoxcore"].has("tox_group_peer_public_key_size", "cdecl"):
|
|
tox_group_peer_public_key_size = _libs["libtoxcore"].get("tox_group_peer_public_key_size", "cdecl")
|
|
tox_group_peer_public_key_size.argtypes = []
|
|
tox_group_peer_public_key_size.restype = uint32_t
|
|
else: LOG_ERROR("tox_group_peer_public_key_size")
|
|
|
|
enum_Tox_Group_Privacy_State = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 3457
|
|
|
|
TOX_GROUP_PRIVACY_STATE_PUBLIC = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 3457
|
|
|
|
TOX_GROUP_PRIVACY_STATE_PRIVATE = (TOX_GROUP_PRIVACY_STATE_PUBLIC + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3457
|
|
|
|
Tox_Group_Privacy_State = enum_Tox_Group_Privacy_State# /usr/local/src/c-toxcore/toxcore/tox.h: 3457
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3459
|
|
if _libs["libtoxcore"].has("tox_group_privacy_state_to_string", "cdecl"):
|
|
tox_group_privacy_state_to_string = _libs["libtoxcore"].get("tox_group_privacy_state_to_string", "cdecl")
|
|
tox_group_privacy_state_to_string.argtypes = [Tox_Group_Privacy_State]
|
|
tox_group_privacy_state_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_group_privacy_state_to_string")
|
|
|
|
enum_Tox_Group_Topic_Lock = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 3476
|
|
|
|
TOX_GROUP_TOPIC_LOCK_ENABLED = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 3476
|
|
|
|
TOX_GROUP_TOPIC_LOCK_DISABLED = (TOX_GROUP_TOPIC_LOCK_ENABLED + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3476
|
|
|
|
Tox_Group_Topic_Lock = enum_Tox_Group_Topic_Lock# /usr/local/src/c-toxcore/toxcore/tox.h: 3476
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3478
|
|
if _libs["libtoxcore"].has("tox_group_topic_lock_to_string", "cdecl"):
|
|
tox_group_topic_lock_to_string = _libs["libtoxcore"].get("tox_group_topic_lock_to_string", "cdecl")
|
|
tox_group_topic_lock_to_string.argtypes = [Tox_Group_Topic_Lock]
|
|
tox_group_topic_lock_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_group_topic_lock_to_string")
|
|
|
|
enum_Tox_Group_Voice_State = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 3499
|
|
|
|
TOX_GROUP_VOICE_STATE_ALL = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 3499
|
|
|
|
TOX_GROUP_VOICE_STATE_MODERATOR = (TOX_GROUP_VOICE_STATE_ALL + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3499
|
|
|
|
TOX_GROUP_VOICE_STATE_FOUNDER = (TOX_GROUP_VOICE_STATE_MODERATOR + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3499
|
|
|
|
Tox_Group_Voice_State = enum_Tox_Group_Voice_State# /usr/local/src/c-toxcore/toxcore/tox.h: 3499
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3501
|
|
if _libs["libtoxcore"].has("tox_group_voice_state_to_string", "cdecl"):
|
|
tox_group_voice_state_to_string = _libs["libtoxcore"].get("tox_group_voice_state_to_string", "cdecl")
|
|
tox_group_voice_state_to_string.argtypes = [Tox_Group_Voice_State]
|
|
tox_group_voice_state_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_group_voice_state_to_string")
|
|
|
|
enum_Tox_Group_Role = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 3533
|
|
|
|
TOX_GROUP_ROLE_FOUNDER = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 3533
|
|
|
|
TOX_GROUP_ROLE_MODERATOR = (TOX_GROUP_ROLE_FOUNDER + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3533
|
|
|
|
TOX_GROUP_ROLE_USER = (TOX_GROUP_ROLE_MODERATOR + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3533
|
|
|
|
TOX_GROUP_ROLE_OBSERVER = (TOX_GROUP_ROLE_USER + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3533
|
|
|
|
Tox_Group_Role = enum_Tox_Group_Role# /usr/local/src/c-toxcore/toxcore/tox.h: 3533
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3535
|
|
if _libs["libtoxcore"].has("tox_group_role_to_string", "cdecl"):
|
|
tox_group_role_to_string = _libs["libtoxcore"].get("tox_group_role_to_string", "cdecl")
|
|
tox_group_role_to_string.argtypes = [Tox_Group_Role]
|
|
tox_group_role_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_group_role_to_string")
|
|
|
|
enum_Tox_Err_Group_New = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 3576
|
|
|
|
TOX_ERR_GROUP_NEW_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 3576
|
|
|
|
TOX_ERR_GROUP_NEW_TOO_LONG = (TOX_ERR_GROUP_NEW_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3576
|
|
|
|
TOX_ERR_GROUP_NEW_EMPTY = (TOX_ERR_GROUP_NEW_TOO_LONG + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3576
|
|
|
|
TOX_ERR_GROUP_NEW_INIT = (TOX_ERR_GROUP_NEW_EMPTY + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3576
|
|
|
|
TOX_ERR_GROUP_NEW_STATE = (TOX_ERR_GROUP_NEW_INIT + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3576
|
|
|
|
TOX_ERR_GROUP_NEW_ANNOUNCE = (TOX_ERR_GROUP_NEW_STATE + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3576
|
|
|
|
Tox_Err_Group_New = enum_Tox_Err_Group_New# /usr/local/src/c-toxcore/toxcore/tox.h: 3576
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3578
|
|
if _libs["libtoxcore"].has("tox_err_group_new_to_string", "cdecl"):
|
|
tox_err_group_new_to_string = _libs["libtoxcore"].get("tox_err_group_new_to_string", "cdecl")
|
|
tox_err_group_new_to_string.argtypes = [Tox_Err_Group_New]
|
|
tox_err_group_new_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_group_new_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3602
|
|
if _libs["libtoxcore"].has("tox_group_new", "cdecl"):
|
|
tox_group_new = _libs["libtoxcore"].get("tox_group_new", "cdecl")
|
|
tox_group_new.argtypes = [POINTER(Tox), Tox_Group_Privacy_State, POINTER(uint8_t), c_size_t, POINTER(uint8_t), c_size_t, POINTER(Tox_Err_Group_New)]
|
|
tox_group_new.restype = Tox_Group_Number
|
|
else: LOG_ERROR("tox_group_new")
|
|
|
|
enum_Tox_Err_Group_Join = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 3645
|
|
|
|
TOX_ERR_GROUP_JOIN_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 3645
|
|
|
|
TOX_ERR_GROUP_JOIN_INIT = (TOX_ERR_GROUP_JOIN_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3645
|
|
|
|
TOX_ERR_GROUP_JOIN_BAD_CHAT_ID = (TOX_ERR_GROUP_JOIN_INIT + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3645
|
|
|
|
TOX_ERR_GROUP_JOIN_EMPTY = (TOX_ERR_GROUP_JOIN_BAD_CHAT_ID + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3645
|
|
|
|
TOX_ERR_GROUP_JOIN_TOO_LONG = (TOX_ERR_GROUP_JOIN_EMPTY + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3645
|
|
|
|
TOX_ERR_GROUP_JOIN_PASSWORD = (TOX_ERR_GROUP_JOIN_TOO_LONG + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3645
|
|
|
|
TOX_ERR_GROUP_JOIN_CORE = (TOX_ERR_GROUP_JOIN_PASSWORD + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3645
|
|
|
|
Tox_Err_Group_Join = enum_Tox_Err_Group_Join# /usr/local/src/c-toxcore/toxcore/tox.h: 3645
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3647
|
|
if _libs["libtoxcore"].has("tox_err_group_join_to_string", "cdecl"):
|
|
tox_err_group_join_to_string = _libs["libtoxcore"].get("tox_err_group_join_to_string", "cdecl")
|
|
tox_err_group_join_to_string.argtypes = [Tox_Err_Group_Join]
|
|
tox_err_group_join_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_group_join_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3666
|
|
if _libs["libtoxcore"].has("tox_group_join", "cdecl"):
|
|
tox_group_join = _libs["libtoxcore"].get("tox_group_join", "cdecl")
|
|
tox_group_join.argtypes = [POINTER(Tox), uint8_t * int(32), POINTER(uint8_t), c_size_t, POINTER(uint8_t), c_size_t, POINTER(Tox_Err_Group_Join)]
|
|
tox_group_join.restype = Tox_Group_Number
|
|
else: LOG_ERROR("tox_group_join")
|
|
|
|
enum_Tox_Err_Group_Is_Connected = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 3684
|
|
|
|
TOX_ERR_GROUP_IS_CONNECTED_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 3684
|
|
|
|
TOX_ERR_GROUP_IS_CONNECTED_GROUP_NOT_FOUND = (TOX_ERR_GROUP_IS_CONNECTED_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3684
|
|
|
|
Tox_Err_Group_Is_Connected = enum_Tox_Err_Group_Is_Connected# /usr/local/src/c-toxcore/toxcore/tox.h: 3684
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3686
|
|
if _libs["libtoxcore"].has("tox_err_group_is_connected_to_string", "cdecl"):
|
|
tox_err_group_is_connected_to_string = _libs["libtoxcore"].get("tox_err_group_is_connected_to_string", "cdecl")
|
|
tox_err_group_is_connected_to_string.argtypes = [Tox_Err_Group_Is_Connected]
|
|
tox_err_group_is_connected_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_group_is_connected_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3694
|
|
if _libs["libtoxcore"].has("tox_group_is_connected", "cdecl"):
|
|
tox_group_is_connected = _libs["libtoxcore"].get("tox_group_is_connected", "cdecl")
|
|
tox_group_is_connected.argtypes = [POINTER(Tox), Tox_Group_Number, POINTER(Tox_Err_Group_Is_Connected)]
|
|
tox_group_is_connected.restype = c_bool
|
|
else: LOG_ERROR("tox_group_is_connected")
|
|
|
|
enum_Tox_Err_Group_Disconnect = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 3712
|
|
|
|
TOX_ERR_GROUP_DISCONNECT_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 3712
|
|
|
|
TOX_ERR_GROUP_DISCONNECT_GROUP_NOT_FOUND = (TOX_ERR_GROUP_DISCONNECT_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3712
|
|
|
|
TOX_ERR_GROUP_DISCONNECT_ALREADY_DISCONNECTED = (TOX_ERR_GROUP_DISCONNECT_GROUP_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3712
|
|
|
|
Tox_Err_Group_Disconnect = enum_Tox_Err_Group_Disconnect# /usr/local/src/c-toxcore/toxcore/tox.h: 3712
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3714
|
|
if _libs["libtoxcore"].has("tox_err_group_disconnect_to_string", "cdecl"):
|
|
tox_err_group_disconnect_to_string = _libs["libtoxcore"].get("tox_err_group_disconnect_to_string", "cdecl")
|
|
tox_err_group_disconnect_to_string.argtypes = [Tox_Err_Group_Disconnect]
|
|
tox_err_group_disconnect_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_group_disconnect_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3723
|
|
if _libs["libtoxcore"].has("tox_group_disconnect", "cdecl"):
|
|
tox_group_disconnect = _libs["libtoxcore"].get("tox_group_disconnect", "cdecl")
|
|
tox_group_disconnect.argtypes = [POINTER(Tox), Tox_Group_Number, POINTER(Tox_Err_Group_Disconnect)]
|
|
tox_group_disconnect.restype = c_bool
|
|
else: LOG_ERROR("tox_group_disconnect")
|
|
|
|
enum_Tox_Err_Group_Reconnect = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 3742
|
|
|
|
TOX_ERR_GROUP_RECONNECT_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 3742
|
|
|
|
TOX_ERR_GROUP_RECONNECT_GROUP_NOT_FOUND = (TOX_ERR_GROUP_RECONNECT_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3742
|
|
|
|
TOX_ERR_GROUP_RECONNECT_CORE = (TOX_ERR_GROUP_RECONNECT_GROUP_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3742
|
|
|
|
Tox_Err_Group_Reconnect = enum_Tox_Err_Group_Reconnect# /usr/local/src/c-toxcore/toxcore/tox.h: 3742
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3744
|
|
if _libs["libtoxcore"].has("tox_err_group_reconnect_to_string", "cdecl"):
|
|
tox_err_group_reconnect_to_string = _libs["libtoxcore"].get("tox_err_group_reconnect_to_string", "cdecl")
|
|
tox_err_group_reconnect_to_string.argtypes = [Tox_Err_Group_Reconnect]
|
|
tox_err_group_reconnect_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_group_reconnect_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3756
|
|
if _libs["libtoxcore"].has("tox_group_reconnect", "cdecl"):
|
|
tox_group_reconnect = _libs["libtoxcore"].get("tox_group_reconnect", "cdecl")
|
|
tox_group_reconnect.argtypes = [POINTER(Tox), Tox_Group_Number, POINTER(Tox_Err_Group_Reconnect)]
|
|
tox_group_reconnect.restype = c_bool
|
|
else: LOG_ERROR("tox_group_reconnect")
|
|
|
|
enum_Tox_Err_Group_Leave = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 3779
|
|
|
|
TOX_ERR_GROUP_LEAVE_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 3779
|
|
|
|
TOX_ERR_GROUP_LEAVE_GROUP_NOT_FOUND = (TOX_ERR_GROUP_LEAVE_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3779
|
|
|
|
TOX_ERR_GROUP_LEAVE_TOO_LONG = (TOX_ERR_GROUP_LEAVE_GROUP_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3779
|
|
|
|
TOX_ERR_GROUP_LEAVE_FAIL_SEND = (TOX_ERR_GROUP_LEAVE_TOO_LONG + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3779
|
|
|
|
Tox_Err_Group_Leave = enum_Tox_Err_Group_Leave# /usr/local/src/c-toxcore/toxcore/tox.h: 3779
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3781
|
|
if _libs["libtoxcore"].has("tox_err_group_leave_to_string", "cdecl"):
|
|
tox_err_group_leave_to_string = _libs["libtoxcore"].get("tox_err_group_leave_to_string", "cdecl")
|
|
tox_err_group_leave_to_string.argtypes = [Tox_Err_Group_Leave]
|
|
tox_err_group_leave_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_group_leave_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3797
|
|
if _libs["libtoxcore"].has("tox_group_leave", "cdecl"):
|
|
tox_group_leave = _libs["libtoxcore"].get("tox_group_leave", "cdecl")
|
|
tox_group_leave.argtypes = [POINTER(Tox), Tox_Group_Number, POINTER(uint8_t), c_size_t, POINTER(Tox_Err_Group_Leave)]
|
|
tox_group_leave.restype = c_bool
|
|
else: LOG_ERROR("tox_group_leave")
|
|
|
|
enum_Tox_Err_Group_Self_Query = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 3823
|
|
|
|
TOX_ERR_GROUP_SELF_QUERY_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 3823
|
|
|
|
TOX_ERR_GROUP_SELF_QUERY_GROUP_NOT_FOUND = (TOX_ERR_GROUP_SELF_QUERY_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3823
|
|
|
|
Tox_Err_Group_Self_Query = enum_Tox_Err_Group_Self_Query# /usr/local/src/c-toxcore/toxcore/tox.h: 3823
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3825
|
|
if _libs["libtoxcore"].has("tox_err_group_self_query_to_string", "cdecl"):
|
|
tox_err_group_self_query_to_string = _libs["libtoxcore"].get("tox_err_group_self_query_to_string", "cdecl")
|
|
tox_err_group_self_query_to_string.argtypes = [Tox_Err_Group_Self_Query]
|
|
tox_err_group_self_query_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_group_self_query_to_string")
|
|
|
|
enum_Tox_Err_Group_Self_Name_Set = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 3857
|
|
|
|
TOX_ERR_GROUP_SELF_NAME_SET_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 3857
|
|
|
|
TOX_ERR_GROUP_SELF_NAME_SET_GROUP_NOT_FOUND = (TOX_ERR_GROUP_SELF_NAME_SET_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3857
|
|
|
|
TOX_ERR_GROUP_SELF_NAME_SET_TOO_LONG = (TOX_ERR_GROUP_SELF_NAME_SET_GROUP_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3857
|
|
|
|
TOX_ERR_GROUP_SELF_NAME_SET_INVALID = (TOX_ERR_GROUP_SELF_NAME_SET_TOO_LONG + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3857
|
|
|
|
TOX_ERR_GROUP_SELF_NAME_SET_FAIL_SEND = (TOX_ERR_GROUP_SELF_NAME_SET_INVALID + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3857
|
|
|
|
Tox_Err_Group_Self_Name_Set = enum_Tox_Err_Group_Self_Name_Set# /usr/local/src/c-toxcore/toxcore/tox.h: 3857
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3859
|
|
if _libs["libtoxcore"].has("tox_err_group_self_name_set_to_string", "cdecl"):
|
|
tox_err_group_self_name_set_to_string = _libs["libtoxcore"].get("tox_err_group_self_name_set_to_string", "cdecl")
|
|
tox_err_group_self_name_set_to_string.argtypes = [Tox_Err_Group_Self_Name_Set]
|
|
tox_err_group_self_name_set_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_group_self_name_set_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3872
|
|
if _libs["libtoxcore"].has("tox_group_self_set_name", "cdecl"):
|
|
tox_group_self_set_name = _libs["libtoxcore"].get("tox_group_self_set_name", "cdecl")
|
|
tox_group_self_set_name.argtypes = [POINTER(Tox), Tox_Group_Number, POINTER(uint8_t), c_size_t, POINTER(Tox_Err_Group_Self_Name_Set)]
|
|
tox_group_self_set_name.restype = c_bool
|
|
else: LOG_ERROR("tox_group_self_set_name")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3886
|
|
if _libs["libtoxcore"].has("tox_group_self_get_name_size", "cdecl"):
|
|
tox_group_self_get_name_size = _libs["libtoxcore"].get("tox_group_self_get_name_size", "cdecl")
|
|
tox_group_self_get_name_size.argtypes = [POINTER(Tox), Tox_Group_Number, POINTER(Tox_Err_Group_Self_Query)]
|
|
tox_group_self_get_name_size.restype = c_size_t
|
|
else: LOG_ERROR("tox_group_self_get_name_size")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3901
|
|
if _libs["libtoxcore"].has("tox_group_self_get_name", "cdecl"):
|
|
tox_group_self_get_name = _libs["libtoxcore"].get("tox_group_self_get_name", "cdecl")
|
|
tox_group_self_get_name.argtypes = [POINTER(Tox), Tox_Group_Number, POINTER(uint8_t), POINTER(Tox_Err_Group_Self_Query)]
|
|
tox_group_self_get_name.restype = c_bool
|
|
else: LOG_ERROR("tox_group_self_get_name")
|
|
|
|
enum_Tox_Err_Group_Self_Status_Set = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 3925
|
|
|
|
TOX_ERR_GROUP_SELF_STATUS_SET_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 3925
|
|
|
|
TOX_ERR_GROUP_SELF_STATUS_SET_GROUP_NOT_FOUND = (TOX_ERR_GROUP_SELF_STATUS_SET_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3925
|
|
|
|
TOX_ERR_GROUP_SELF_STATUS_SET_FAIL_SEND = (TOX_ERR_GROUP_SELF_STATUS_SET_GROUP_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3925
|
|
|
|
Tox_Err_Group_Self_Status_Set = enum_Tox_Err_Group_Self_Status_Set# /usr/local/src/c-toxcore/toxcore/tox.h: 3925
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3927
|
|
if _libs["libtoxcore"].has("tox_err_group_self_status_set_to_string", "cdecl"):
|
|
tox_err_group_self_status_set_to_string = _libs["libtoxcore"].get("tox_err_group_self_status_set_to_string", "cdecl")
|
|
tox_err_group_self_status_set_to_string.argtypes = [Tox_Err_Group_Self_Status_Set]
|
|
tox_err_group_self_status_set_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_group_self_status_set_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3934
|
|
if _libs["libtoxcore"].has("tox_group_self_set_status", "cdecl"):
|
|
tox_group_self_set_status = _libs["libtoxcore"].get("tox_group_self_set_status", "cdecl")
|
|
tox_group_self_set_status.argtypes = [POINTER(Tox), Tox_Group_Number, Tox_User_Status, POINTER(Tox_Err_Group_Self_Status_Set)]
|
|
tox_group_self_set_status.restype = c_bool
|
|
else: LOG_ERROR("tox_group_self_set_status")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3941
|
|
if _libs["libtoxcore"].has("tox_group_self_get_status", "cdecl"):
|
|
tox_group_self_get_status = _libs["libtoxcore"].get("tox_group_self_get_status", "cdecl")
|
|
tox_group_self_get_status.argtypes = [POINTER(Tox), Tox_Group_Number, POINTER(Tox_Err_Group_Self_Query)]
|
|
tox_group_self_get_status.restype = Tox_User_Status
|
|
else: LOG_ERROR("tox_group_self_get_status")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3947
|
|
if _libs["libtoxcore"].has("tox_group_self_get_role", "cdecl"):
|
|
tox_group_self_get_role = _libs["libtoxcore"].get("tox_group_self_get_role", "cdecl")
|
|
tox_group_self_get_role.argtypes = [POINTER(Tox), Tox_Group_Number, POINTER(Tox_Err_Group_Self_Query)]
|
|
tox_group_self_get_role.restype = Tox_Group_Role
|
|
else: LOG_ERROR("tox_group_self_get_role")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3953
|
|
if _libs["libtoxcore"].has("tox_group_self_get_peer_id", "cdecl"):
|
|
tox_group_self_get_peer_id = _libs["libtoxcore"].get("tox_group_self_get_peer_id", "cdecl")
|
|
tox_group_self_get_peer_id.argtypes = [POINTER(Tox), Tox_Group_Number, POINTER(Tox_Err_Group_Self_Query)]
|
|
tox_group_self_get_peer_id.restype = Tox_Group_Peer_Number
|
|
else: LOG_ERROR("tox_group_self_get_peer_id")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3969
|
|
if _libs["libtoxcore"].has("tox_group_self_get_public_key", "cdecl"):
|
|
tox_group_self_get_public_key = _libs["libtoxcore"].get("tox_group_self_get_public_key", "cdecl")
|
|
tox_group_self_get_public_key.argtypes = [POINTER(Tox), Tox_Group_Number, uint8_t * int(32), POINTER(Tox_Err_Group_Self_Query)]
|
|
tox_group_self_get_public_key.restype = c_bool
|
|
else: LOG_ERROR("tox_group_self_get_public_key")
|
|
|
|
enum_Tox_Err_Group_Peer_Query = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 3998
|
|
|
|
TOX_ERR_GROUP_PEER_QUERY_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 3998
|
|
|
|
TOX_ERR_GROUP_PEER_QUERY_GROUP_NOT_FOUND = (TOX_ERR_GROUP_PEER_QUERY_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3998
|
|
|
|
TOX_ERR_GROUP_PEER_QUERY_PEER_NOT_FOUND = (TOX_ERR_GROUP_PEER_QUERY_GROUP_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 3998
|
|
|
|
Tox_Err_Group_Peer_Query = enum_Tox_Err_Group_Peer_Query# /usr/local/src/c-toxcore/toxcore/tox.h: 3998
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4000
|
|
if _libs["libtoxcore"].has("tox_err_group_peer_query_to_string", "cdecl"):
|
|
tox_err_group_peer_query_to_string = _libs["libtoxcore"].get("tox_err_group_peer_query_to_string", "cdecl")
|
|
tox_err_group_peer_query_to_string.argtypes = [Tox_Err_Group_Peer_Query]
|
|
tox_err_group_peer_query_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_group_peer_query_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4012
|
|
if _libs["libtoxcore"].has("tox_group_peer_get_name_size", "cdecl"):
|
|
tox_group_peer_get_name_size = _libs["libtoxcore"].get("tox_group_peer_get_name_size", "cdecl")
|
|
tox_group_peer_get_name_size.argtypes = [POINTER(Tox), Tox_Group_Number, Tox_Group_Peer_Number, POINTER(Tox_Err_Group_Peer_Query)]
|
|
tox_group_peer_get_name_size.restype = c_size_t
|
|
else: LOG_ERROR("tox_group_peer_get_name_size")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4030
|
|
if _libs["libtoxcore"].has("tox_group_peer_get_name", "cdecl"):
|
|
tox_group_peer_get_name = _libs["libtoxcore"].get("tox_group_peer_get_name", "cdecl")
|
|
tox_group_peer_get_name.argtypes = [POINTER(Tox), Tox_Group_Number, Tox_Group_Peer_Number, POINTER(uint8_t), POINTER(Tox_Err_Group_Peer_Query)]
|
|
tox_group_peer_get_name.restype = c_bool
|
|
else: LOG_ERROR("tox_group_peer_get_name")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4044
|
|
if _libs["libtoxcore"].has("tox_group_peer_get_status", "cdecl"):
|
|
tox_group_peer_get_status = _libs["libtoxcore"].get("tox_group_peer_get_status", "cdecl")
|
|
tox_group_peer_get_status.argtypes = [POINTER(Tox), Tox_Group_Number, Tox_Group_Peer_Number, POINTER(Tox_Err_Group_Peer_Query)]
|
|
tox_group_peer_get_status.restype = Tox_User_Status
|
|
else: LOG_ERROR("tox_group_peer_get_status")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4057
|
|
if _libs["libtoxcore"].has("tox_group_peer_get_role", "cdecl"):
|
|
tox_group_peer_get_role = _libs["libtoxcore"].get("tox_group_peer_get_role", "cdecl")
|
|
tox_group_peer_get_role.argtypes = [POINTER(Tox), Tox_Group_Number, Tox_Group_Peer_Number, POINTER(Tox_Err_Group_Peer_Query)]
|
|
tox_group_peer_get_role.restype = Tox_Group_Role
|
|
else: LOG_ERROR("tox_group_peer_get_role")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4069
|
|
if _libs["libtoxcore"].has("tox_group_peer_get_connection_status", "cdecl"):
|
|
tox_group_peer_get_connection_status = _libs["libtoxcore"].get("tox_group_peer_get_connection_status", "cdecl")
|
|
tox_group_peer_get_connection_status.argtypes = [POINTER(Tox), Tox_Group_Number, Tox_Group_Peer_Number, POINTER(Tox_Err_Group_Peer_Query)]
|
|
tox_group_peer_get_connection_status.restype = Tox_Connection
|
|
else: LOG_ERROR("tox_group_peer_get_connection_status")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4088
|
|
if _libs["libtoxcore"].has("tox_group_peer_get_public_key", "cdecl"):
|
|
tox_group_peer_get_public_key = _libs["libtoxcore"].get("tox_group_peer_get_public_key", "cdecl")
|
|
tox_group_peer_get_public_key.argtypes = [POINTER(Tox), Tox_Group_Number, Tox_Group_Peer_Number, uint8_t * int(32), POINTER(Tox_Err_Group_Peer_Query)]
|
|
tox_group_peer_get_public_key.restype = c_bool
|
|
else: LOG_ERROR("tox_group_peer_get_public_key")
|
|
|
|
tox_group_peer_name_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Group_Number, Tox_Group_Peer_Number, POINTER(uint8_t), c_size_t, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 4098
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4107
|
|
if _libs["libtoxcore"].has("tox_callback_group_peer_name", "cdecl"):
|
|
tox_callback_group_peer_name = _libs["libtoxcore"].get("tox_callback_group_peer_name", "cdecl")
|
|
tox_callback_group_peer_name.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_group_peer_name_cb)
|
|
tox_callback_group_peer_name.restype = None
|
|
else: LOG_ERROR("tox_callback_group_peer_name")
|
|
|
|
tox_group_peer_status_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Group_Number, Tox_Group_Peer_Number, Tox_User_Status, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 4114
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4122
|
|
if _libs["libtoxcore"].has("tox_callback_group_peer_status", "cdecl"):
|
|
tox_callback_group_peer_status = _libs["libtoxcore"].get("tox_callback_group_peer_status", "cdecl")
|
|
tox_callback_group_peer_status.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_group_peer_status_cb)
|
|
tox_callback_group_peer_status.restype = None
|
|
else: LOG_ERROR("tox_callback_group_peer_status")
|
|
|
|
enum_Tox_Err_Group_State_Queries = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 4145
|
|
|
|
TOX_ERR_GROUP_STATE_QUERIES_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 4145
|
|
|
|
TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND = (TOX_ERR_GROUP_STATE_QUERIES_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4145
|
|
|
|
Tox_Err_Group_State_Queries = enum_Tox_Err_Group_State_Queries# /usr/local/src/c-toxcore/toxcore/tox.h: 4145
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4147
|
|
if _libs["libtoxcore"].has("tox_err_group_state_queries_to_string", "cdecl"):
|
|
tox_err_group_state_queries_to_string = _libs["libtoxcore"].get("tox_err_group_state_queries_to_string", "cdecl")
|
|
tox_err_group_state_queries_to_string.argtypes = [Tox_Err_Group_State_Queries]
|
|
tox_err_group_state_queries_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_group_state_queries_to_string")
|
|
|
|
enum_Tox_Err_Group_Topic_Set = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 4189
|
|
|
|
TOX_ERR_GROUP_TOPIC_SET_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 4189
|
|
|
|
TOX_ERR_GROUP_TOPIC_SET_GROUP_NOT_FOUND = (TOX_ERR_GROUP_TOPIC_SET_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4189
|
|
|
|
TOX_ERR_GROUP_TOPIC_SET_TOO_LONG = (TOX_ERR_GROUP_TOPIC_SET_GROUP_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4189
|
|
|
|
TOX_ERR_GROUP_TOPIC_SET_PERMISSIONS = (TOX_ERR_GROUP_TOPIC_SET_TOO_LONG + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4189
|
|
|
|
TOX_ERR_GROUP_TOPIC_SET_FAIL_CREATE = (TOX_ERR_GROUP_TOPIC_SET_PERMISSIONS + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4189
|
|
|
|
TOX_ERR_GROUP_TOPIC_SET_FAIL_SEND = (TOX_ERR_GROUP_TOPIC_SET_FAIL_CREATE + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4189
|
|
|
|
TOX_ERR_GROUP_TOPIC_SET_DISCONNECTED = (TOX_ERR_GROUP_TOPIC_SET_FAIL_SEND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4189
|
|
|
|
Tox_Err_Group_Topic_Set = enum_Tox_Err_Group_Topic_Set# /usr/local/src/c-toxcore/toxcore/tox.h: 4189
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4191
|
|
if _libs["libtoxcore"].has("tox_err_group_topic_set_to_string", "cdecl"):
|
|
tox_err_group_topic_set_to_string = _libs["libtoxcore"].get("tox_err_group_topic_set_to_string", "cdecl")
|
|
tox_err_group_topic_set_to_string.argtypes = [Tox_Err_Group_Topic_Set]
|
|
tox_err_group_topic_set_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_group_topic_set_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4201
|
|
if _libs["libtoxcore"].has("tox_group_set_topic", "cdecl"):
|
|
tox_group_set_topic = _libs["libtoxcore"].get("tox_group_set_topic", "cdecl")
|
|
tox_group_set_topic.argtypes = [POINTER(Tox), Tox_Group_Number, POINTER(uint8_t), c_size_t, POINTER(Tox_Err_Group_Topic_Set)]
|
|
tox_group_set_topic.restype = c_bool
|
|
else: LOG_ERROR("tox_group_set_topic")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4213
|
|
if _libs["libtoxcore"].has("tox_group_get_topic_size", "cdecl"):
|
|
tox_group_get_topic_size = _libs["libtoxcore"].get("tox_group_get_topic_size", "cdecl")
|
|
tox_group_get_topic_size.argtypes = [POINTER(Tox), Tox_Group_Number, POINTER(Tox_Err_Group_State_Queries)]
|
|
tox_group_get_topic_size.restype = c_size_t
|
|
else: LOG_ERROR("tox_group_get_topic_size")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4228
|
|
if _libs["libtoxcore"].has("tox_group_get_topic", "cdecl"):
|
|
tox_group_get_topic = _libs["libtoxcore"].get("tox_group_get_topic", "cdecl")
|
|
tox_group_get_topic.argtypes = [POINTER(Tox), Tox_Group_Number, POINTER(uint8_t), POINTER(Tox_Err_Group_State_Queries)]
|
|
tox_group_get_topic.restype = c_bool
|
|
else: LOG_ERROR("tox_group_get_topic")
|
|
|
|
tox_group_topic_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Group_Number, Tox_Group_Peer_Number, POINTER(uint8_t), c_size_t, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 4239
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4249
|
|
if _libs["libtoxcore"].has("tox_callback_group_topic", "cdecl"):
|
|
tox_callback_group_topic = _libs["libtoxcore"].get("tox_callback_group_topic", "cdecl")
|
|
tox_callback_group_topic.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_group_topic_cb)
|
|
tox_callback_group_topic.restype = None
|
|
else: LOG_ERROR("tox_callback_group_topic")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4255
|
|
if _libs["libtoxcore"].has("tox_group_get_name_size", "cdecl"):
|
|
tox_group_get_name_size = _libs["libtoxcore"].get("tox_group_get_name_size", "cdecl")
|
|
tox_group_get_name_size.argtypes = [POINTER(Tox), Tox_Group_Number, POINTER(Tox_Err_Group_State_Queries)]
|
|
tox_group_get_name_size.restype = c_size_t
|
|
else: LOG_ERROR("tox_group_get_name_size")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4267
|
|
if _libs["libtoxcore"].has("tox_group_get_name", "cdecl"):
|
|
tox_group_get_name = _libs["libtoxcore"].get("tox_group_get_name", "cdecl")
|
|
tox_group_get_name.argtypes = [POINTER(Tox), Tox_Group_Number, POINTER(uint8_t), POINTER(Tox_Err_Group_State_Queries)]
|
|
tox_group_get_name.restype = c_bool
|
|
else: LOG_ERROR("tox_group_get_name")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4281
|
|
if _libs["libtoxcore"].has("tox_group_get_chat_id", "cdecl"):
|
|
tox_group_get_chat_id = _libs["libtoxcore"].get("tox_group_get_chat_id", "cdecl")
|
|
tox_group_get_chat_id.argtypes = [POINTER(Tox), Tox_Group_Number, uint8_t * int(32), POINTER(Tox_Err_Group_State_Queries)]
|
|
tox_group_get_chat_id.restype = c_bool
|
|
else: LOG_ERROR("tox_group_get_chat_id")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4288
|
|
if _libs["libtoxcore"].has("tox_group_get_number_groups", "cdecl"):
|
|
tox_group_get_number_groups = _libs["libtoxcore"].get("tox_group_get_number_groups", "cdecl")
|
|
tox_group_get_number_groups.argtypes = [POINTER(Tox)]
|
|
tox_group_get_number_groups.restype = uint32_t
|
|
else: LOG_ERROR("tox_group_get_number_groups")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4299
|
|
if _libs["libtoxcore"].has("tox_group_get_privacy_state", "cdecl"):
|
|
tox_group_get_privacy_state = _libs["libtoxcore"].get("tox_group_get_privacy_state", "cdecl")
|
|
tox_group_get_privacy_state.argtypes = [POINTER(Tox), Tox_Group_Number, POINTER(Tox_Err_Group_State_Queries)]
|
|
tox_group_get_privacy_state.restype = Tox_Group_Privacy_State
|
|
else: LOG_ERROR("tox_group_get_privacy_state")
|
|
|
|
tox_group_privacy_state_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Group_Number, Tox_Group_Privacy_State, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 4306
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4314
|
|
if _libs["libtoxcore"].has("tox_callback_group_privacy_state", "cdecl"):
|
|
tox_callback_group_privacy_state = _libs["libtoxcore"].get("tox_callback_group_privacy_state", "cdecl")
|
|
tox_callback_group_privacy_state.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_group_privacy_state_cb)
|
|
tox_callback_group_privacy_state.restype = None
|
|
else: LOG_ERROR("tox_callback_group_privacy_state")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4324
|
|
if _libs["libtoxcore"].has("tox_group_get_voice_state", "cdecl"):
|
|
tox_group_get_voice_state = _libs["libtoxcore"].get("tox_group_get_voice_state", "cdecl")
|
|
tox_group_get_voice_state.argtypes = [POINTER(Tox), Tox_Group_Number, POINTER(Tox_Err_Group_State_Queries)]
|
|
tox_group_get_voice_state.restype = Tox_Group_Voice_State
|
|
else: LOG_ERROR("tox_group_get_voice_state")
|
|
|
|
tox_group_voice_state_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Group_Number, Tox_Group_Voice_State, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 4331
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4339
|
|
if _libs["libtoxcore"].has("tox_callback_group_voice_state", "cdecl"):
|
|
tox_callback_group_voice_state = _libs["libtoxcore"].get("tox_callback_group_voice_state", "cdecl")
|
|
tox_callback_group_voice_state.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_group_voice_state_cb)
|
|
tox_callback_group_voice_state.restype = None
|
|
else: LOG_ERROR("tox_callback_group_voice_state")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4350
|
|
if _libs["libtoxcore"].has("tox_group_get_topic_lock", "cdecl"):
|
|
tox_group_get_topic_lock = _libs["libtoxcore"].get("tox_group_get_topic_lock", "cdecl")
|
|
tox_group_get_topic_lock.argtypes = [POINTER(Tox), Tox_Group_Number, POINTER(Tox_Err_Group_State_Queries)]
|
|
tox_group_get_topic_lock.restype = Tox_Group_Topic_Lock
|
|
else: LOG_ERROR("tox_group_get_topic_lock")
|
|
|
|
tox_group_topic_lock_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Group_Number, Tox_Group_Topic_Lock, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 4357
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4364
|
|
if _libs["libtoxcore"].has("tox_callback_group_topic_lock", "cdecl"):
|
|
tox_callback_group_topic_lock = _libs["libtoxcore"].get("tox_callback_group_topic_lock", "cdecl")
|
|
tox_callback_group_topic_lock.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_group_topic_lock_cb)
|
|
tox_callback_group_topic_lock.restype = None
|
|
else: LOG_ERROR("tox_callback_group_topic_lock")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4375
|
|
if _libs["libtoxcore"].has("tox_group_get_peer_limit", "cdecl"):
|
|
tox_group_get_peer_limit = _libs["libtoxcore"].get("tox_group_get_peer_limit", "cdecl")
|
|
tox_group_get_peer_limit.argtypes = [POINTER(Tox), Tox_Group_Number, POINTER(Tox_Err_Group_State_Queries)]
|
|
tox_group_get_peer_limit.restype = uint16_t
|
|
else: LOG_ERROR("tox_group_get_peer_limit")
|
|
|
|
tox_group_peer_limit_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Group_Number, uint32_t, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 4381
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4388
|
|
if _libs["libtoxcore"].has("tox_callback_group_peer_limit", "cdecl"):
|
|
tox_callback_group_peer_limit = _libs["libtoxcore"].get("tox_callback_group_peer_limit", "cdecl")
|
|
tox_callback_group_peer_limit.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_group_peer_limit_cb)
|
|
tox_callback_group_peer_limit.restype = None
|
|
else: LOG_ERROR("tox_callback_group_peer_limit")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4394
|
|
if _libs["libtoxcore"].has("tox_group_get_password_size", "cdecl"):
|
|
tox_group_get_password_size = _libs["libtoxcore"].get("tox_group_get_password_size", "cdecl")
|
|
tox_group_get_password_size.argtypes = [POINTER(Tox), Tox_Group_Number, POINTER(Tox_Err_Group_State_Queries)]
|
|
tox_group_get_password_size.restype = c_size_t
|
|
else: LOG_ERROR("tox_group_get_password_size")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4411
|
|
if _libs["libtoxcore"].has("tox_group_get_password", "cdecl"):
|
|
tox_group_get_password = _libs["libtoxcore"].get("tox_group_get_password", "cdecl")
|
|
tox_group_get_password.argtypes = [POINTER(Tox), Tox_Group_Number, POINTER(uint8_t), POINTER(Tox_Err_Group_State_Queries)]
|
|
tox_group_get_password.restype = c_bool
|
|
else: LOG_ERROR("tox_group_get_password")
|
|
|
|
tox_group_password_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Group_Number, POINTER(uint8_t), c_size_t, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 4420
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4430
|
|
if _libs["libtoxcore"].has("tox_callback_group_password", "cdecl"):
|
|
tox_callback_group_password = _libs["libtoxcore"].get("tox_callback_group_password", "cdecl")
|
|
tox_callback_group_password.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_group_password_cb)
|
|
tox_callback_group_password.restype = None
|
|
else: LOG_ERROR("tox_callback_group_password")
|
|
|
|
enum_Tox_Err_Group_Send_Message = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 4480
|
|
|
|
TOX_ERR_GROUP_SEND_MESSAGE_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 4480
|
|
|
|
TOX_ERR_GROUP_SEND_MESSAGE_GROUP_NOT_FOUND = (TOX_ERR_GROUP_SEND_MESSAGE_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4480
|
|
|
|
TOX_ERR_GROUP_SEND_MESSAGE_TOO_LONG = (TOX_ERR_GROUP_SEND_MESSAGE_GROUP_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4480
|
|
|
|
TOX_ERR_GROUP_SEND_MESSAGE_EMPTY = (TOX_ERR_GROUP_SEND_MESSAGE_TOO_LONG + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4480
|
|
|
|
TOX_ERR_GROUP_SEND_MESSAGE_BAD_TYPE = (TOX_ERR_GROUP_SEND_MESSAGE_EMPTY + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4480
|
|
|
|
TOX_ERR_GROUP_SEND_MESSAGE_PERMISSIONS = (TOX_ERR_GROUP_SEND_MESSAGE_BAD_TYPE + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4480
|
|
|
|
TOX_ERR_GROUP_SEND_MESSAGE_FAIL_SEND = (TOX_ERR_GROUP_SEND_MESSAGE_PERMISSIONS + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4480
|
|
|
|
TOX_ERR_GROUP_SEND_MESSAGE_DISCONNECTED = (TOX_ERR_GROUP_SEND_MESSAGE_FAIL_SEND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4480
|
|
|
|
Tox_Err_Group_Send_Message = enum_Tox_Err_Group_Send_Message# /usr/local/src/c-toxcore/toxcore/tox.h: 4480
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4482
|
|
if _libs["libtoxcore"].has("tox_err_group_send_message_to_string", "cdecl"):
|
|
tox_err_group_send_message_to_string = _libs["libtoxcore"].get("tox_err_group_send_message_to_string", "cdecl")
|
|
tox_err_group_send_message_to_string.argtypes = [Tox_Err_Group_Send_Message]
|
|
tox_err_group_send_message_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_group_send_message_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4503
|
|
if _libs["libtoxcore"].has("tox_group_send_message", "cdecl"):
|
|
tox_group_send_message = _libs["libtoxcore"].get("tox_group_send_message", "cdecl")
|
|
tox_group_send_message.argtypes = [POINTER(Tox), Tox_Group_Number, Tox_Message_Type, POINTER(uint8_t), c_size_t, POINTER(Tox_Err_Group_Send_Message)]
|
|
tox_group_send_message.restype = Tox_Group_Message_Id
|
|
else: LOG_ERROR("tox_group_send_message")
|
|
|
|
enum_Tox_Err_Group_Send_Private_Message = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 4555
|
|
|
|
TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 4555
|
|
|
|
TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_GROUP_NOT_FOUND = (TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4555
|
|
|
|
TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_PEER_NOT_FOUND = (TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_GROUP_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4555
|
|
|
|
TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_TOO_LONG = (TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_PEER_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4555
|
|
|
|
TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_EMPTY = (TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_TOO_LONG + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4555
|
|
|
|
TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_PERMISSIONS = (TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_EMPTY + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4555
|
|
|
|
TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_FAIL_SEND = (TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_PERMISSIONS + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4555
|
|
|
|
TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_DISCONNECTED = (TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_FAIL_SEND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4555
|
|
|
|
TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_BAD_TYPE = (TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_DISCONNECTED + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4555
|
|
|
|
Tox_Err_Group_Send_Private_Message = enum_Tox_Err_Group_Send_Private_Message# /usr/local/src/c-toxcore/toxcore/tox.h: 4555
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4557
|
|
if _libs["libtoxcore"].has("tox_err_group_send_private_message_to_string", "cdecl"):
|
|
tox_err_group_send_private_message_to_string = _libs["libtoxcore"].get("tox_err_group_send_private_message_to_string", "cdecl")
|
|
tox_err_group_send_private_message_to_string.argtypes = [Tox_Err_Group_Send_Private_Message]
|
|
tox_err_group_send_private_message_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_group_send_private_message_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4577
|
|
if _libs["libtoxcore"].has("tox_group_send_private_message", "cdecl"):
|
|
tox_group_send_private_message = _libs["libtoxcore"].get("tox_group_send_private_message", "cdecl")
|
|
tox_group_send_private_message.argtypes = [POINTER(Tox), Tox_Group_Number, Tox_Group_Peer_Number, Tox_Message_Type, POINTER(uint8_t), c_size_t, POINTER(Tox_Err_Group_Send_Private_Message)]
|
|
tox_group_send_private_message.restype = c_bool
|
|
else: LOG_ERROR("tox_group_send_private_message")
|
|
|
|
enum_Tox_Err_Group_Send_Custom_Packet = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 4622
|
|
|
|
TOX_ERR_GROUP_SEND_CUSTOM_PACKET_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 4622
|
|
|
|
TOX_ERR_GROUP_SEND_CUSTOM_PACKET_GROUP_NOT_FOUND = (TOX_ERR_GROUP_SEND_CUSTOM_PACKET_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4622
|
|
|
|
TOX_ERR_GROUP_SEND_CUSTOM_PACKET_TOO_LONG = (TOX_ERR_GROUP_SEND_CUSTOM_PACKET_GROUP_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4622
|
|
|
|
TOX_ERR_GROUP_SEND_CUSTOM_PACKET_EMPTY = (TOX_ERR_GROUP_SEND_CUSTOM_PACKET_TOO_LONG + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4622
|
|
|
|
TOX_ERR_GROUP_SEND_CUSTOM_PACKET_PERMISSIONS = (TOX_ERR_GROUP_SEND_CUSTOM_PACKET_EMPTY + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4622
|
|
|
|
TOX_ERR_GROUP_SEND_CUSTOM_PACKET_DISCONNECTED = (TOX_ERR_GROUP_SEND_CUSTOM_PACKET_PERMISSIONS + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4622
|
|
|
|
TOX_ERR_GROUP_SEND_CUSTOM_PACKET_FAIL_SEND = (TOX_ERR_GROUP_SEND_CUSTOM_PACKET_DISCONNECTED + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4622
|
|
|
|
Tox_Err_Group_Send_Custom_Packet = enum_Tox_Err_Group_Send_Custom_Packet# /usr/local/src/c-toxcore/toxcore/tox.h: 4622
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4624
|
|
if _libs["libtoxcore"].has("tox_err_group_send_custom_packet_to_string", "cdecl"):
|
|
tox_err_group_send_custom_packet_to_string = _libs["libtoxcore"].get("tox_err_group_send_custom_packet_to_string", "cdecl")
|
|
tox_err_group_send_custom_packet_to_string.argtypes = [Tox_Err_Group_Send_Custom_Packet]
|
|
tox_err_group_send_custom_packet_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_group_send_custom_packet_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4650
|
|
if _libs["libtoxcore"].has("tox_group_send_custom_packet", "cdecl"):
|
|
tox_group_send_custom_packet = _libs["libtoxcore"].get("tox_group_send_custom_packet", "cdecl")
|
|
tox_group_send_custom_packet.argtypes = [POINTER(Tox), Tox_Group_Number, c_bool, POINTER(uint8_t), c_size_t, POINTER(Tox_Err_Group_Send_Custom_Packet)]
|
|
tox_group_send_custom_packet.restype = c_bool
|
|
else: LOG_ERROR("tox_group_send_custom_packet")
|
|
|
|
enum_Tox_Err_Group_Send_Custom_Private_Packet = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 4699
|
|
|
|
TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 4699
|
|
|
|
TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_GROUP_NOT_FOUND = (TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4699
|
|
|
|
TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_TOO_LONG = (TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_GROUP_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4699
|
|
|
|
TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_EMPTY = (TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_TOO_LONG + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4699
|
|
|
|
TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_PEER_NOT_FOUND = (TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_EMPTY + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4699
|
|
|
|
TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_PERMISSIONS = (TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_PEER_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4699
|
|
|
|
TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_FAIL_SEND = (TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_PERMISSIONS + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4699
|
|
|
|
TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_DISCONNECTED = (TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_FAIL_SEND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4699
|
|
|
|
Tox_Err_Group_Send_Custom_Private_Packet = enum_Tox_Err_Group_Send_Custom_Private_Packet# /usr/local/src/c-toxcore/toxcore/tox.h: 4699
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4701
|
|
if _libs["libtoxcore"].has("tox_err_group_send_custom_private_packet_to_string", "cdecl"):
|
|
tox_err_group_send_custom_private_packet_to_string = _libs["libtoxcore"].get("tox_err_group_send_custom_private_packet_to_string", "cdecl")
|
|
tox_err_group_send_custom_private_packet_to_string.argtypes = [Tox_Err_Group_Send_Custom_Private_Packet]
|
|
tox_err_group_send_custom_private_packet_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_group_send_custom_private_packet_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4728
|
|
if _libs["libtoxcore"].has("tox_group_send_custom_private_packet", "cdecl"):
|
|
tox_group_send_custom_private_packet = _libs["libtoxcore"].get("tox_group_send_custom_private_packet", "cdecl")
|
|
tox_group_send_custom_private_packet.argtypes = [POINTER(Tox), Tox_Group_Number, Tox_Group_Peer_Number, c_bool, POINTER(uint8_t), c_size_t, POINTER(Tox_Err_Group_Send_Custom_Private_Packet)]
|
|
tox_group_send_custom_private_packet.restype = c_bool
|
|
else: LOG_ERROR("tox_group_send_custom_private_packet")
|
|
|
|
tox_group_message_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Group_Number, Tox_Group_Peer_Number, Tox_Message_Type, POINTER(uint8_t), c_size_t, Tox_Group_Message_Id, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 4746
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4755
|
|
if _libs["libtoxcore"].has("tox_callback_group_message", "cdecl"):
|
|
tox_callback_group_message = _libs["libtoxcore"].get("tox_callback_group_message", "cdecl")
|
|
tox_callback_group_message.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_group_message_cb)
|
|
tox_callback_group_message.restype = None
|
|
else: LOG_ERROR("tox_callback_group_message")
|
|
|
|
tox_group_private_message_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Group_Number, Tox_Group_Peer_Number, Tox_Message_Type, POINTER(uint8_t), c_size_t, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 4763
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4772
|
|
if _libs["libtoxcore"].has("tox_callback_group_private_message", "cdecl"):
|
|
tox_callback_group_private_message = _libs["libtoxcore"].get("tox_callback_group_private_message", "cdecl")
|
|
tox_callback_group_private_message.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_group_private_message_cb)
|
|
tox_callback_group_private_message.restype = None
|
|
else: LOG_ERROR("tox_callback_group_private_message")
|
|
|
|
tox_group_custom_packet_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Group_Number, Tox_Group_Peer_Number, POINTER(uint8_t), c_size_t, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 4780
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4789
|
|
if _libs["libtoxcore"].has("tox_callback_group_custom_packet", "cdecl"):
|
|
tox_callback_group_custom_packet = _libs["libtoxcore"].get("tox_callback_group_custom_packet", "cdecl")
|
|
tox_callback_group_custom_packet.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_group_custom_packet_cb)
|
|
tox_callback_group_custom_packet.restype = None
|
|
else: LOG_ERROR("tox_callback_group_custom_packet")
|
|
|
|
tox_group_custom_private_packet_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Group_Number, Tox_Group_Peer_Number, POINTER(uint8_t), c_size_t, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 4797
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4806
|
|
if _libs["libtoxcore"].has("tox_callback_group_custom_private_packet", "cdecl"):
|
|
tox_callback_group_custom_private_packet = _libs["libtoxcore"].get("tox_callback_group_custom_private_packet", "cdecl")
|
|
tox_callback_group_custom_private_packet.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_group_custom_private_packet_cb)
|
|
tox_callback_group_custom_private_packet.restype = None
|
|
else: LOG_ERROR("tox_callback_group_custom_private_packet")
|
|
|
|
enum_Tox_Err_Group_Invite_Friend = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 4846
|
|
|
|
TOX_ERR_GROUP_INVITE_FRIEND_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 4846
|
|
|
|
TOX_ERR_GROUP_INVITE_FRIEND_GROUP_NOT_FOUND = (TOX_ERR_GROUP_INVITE_FRIEND_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4846
|
|
|
|
TOX_ERR_GROUP_INVITE_FRIEND_FRIEND_NOT_FOUND = (TOX_ERR_GROUP_INVITE_FRIEND_GROUP_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4846
|
|
|
|
TOX_ERR_GROUP_INVITE_FRIEND_INVITE_FAIL = (TOX_ERR_GROUP_INVITE_FRIEND_FRIEND_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4846
|
|
|
|
TOX_ERR_GROUP_INVITE_FRIEND_FAIL_SEND = (TOX_ERR_GROUP_INVITE_FRIEND_INVITE_FAIL + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4846
|
|
|
|
TOX_ERR_GROUP_INVITE_FRIEND_DISCONNECTED = (TOX_ERR_GROUP_INVITE_FRIEND_FAIL_SEND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4846
|
|
|
|
Tox_Err_Group_Invite_Friend = enum_Tox_Err_Group_Invite_Friend# /usr/local/src/c-toxcore/toxcore/tox.h: 4846
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4848
|
|
if _libs["libtoxcore"].has("tox_err_group_invite_friend_to_string", "cdecl"):
|
|
tox_err_group_invite_friend_to_string = _libs["libtoxcore"].get("tox_err_group_invite_friend_to_string", "cdecl")
|
|
tox_err_group_invite_friend_to_string.argtypes = [Tox_Err_Group_Invite_Friend]
|
|
tox_err_group_invite_friend_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_group_invite_friend_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4860
|
|
if _libs["libtoxcore"].has("tox_group_invite_friend", "cdecl"):
|
|
tox_group_invite_friend = _libs["libtoxcore"].get("tox_group_invite_friend", "cdecl")
|
|
tox_group_invite_friend.argtypes = [POINTER(Tox), Tox_Group_Number, Tox_Friend_Number, POINTER(Tox_Err_Group_Invite_Friend)]
|
|
tox_group_invite_friend.restype = c_bool
|
|
else: LOG_ERROR("tox_group_invite_friend")
|
|
|
|
enum_Tox_Err_Group_Invite_Accept = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 4906
|
|
|
|
TOX_ERR_GROUP_INVITE_ACCEPT_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 4906
|
|
|
|
TOX_ERR_GROUP_INVITE_ACCEPT_BAD_INVITE = (TOX_ERR_GROUP_INVITE_ACCEPT_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4906
|
|
|
|
TOX_ERR_GROUP_INVITE_ACCEPT_INIT_FAILED = (TOX_ERR_GROUP_INVITE_ACCEPT_BAD_INVITE + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4906
|
|
|
|
TOX_ERR_GROUP_INVITE_ACCEPT_TOO_LONG = (TOX_ERR_GROUP_INVITE_ACCEPT_INIT_FAILED + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4906
|
|
|
|
TOX_ERR_GROUP_INVITE_ACCEPT_EMPTY = (TOX_ERR_GROUP_INVITE_ACCEPT_TOO_LONG + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4906
|
|
|
|
TOX_ERR_GROUP_INVITE_ACCEPT_PASSWORD = (TOX_ERR_GROUP_INVITE_ACCEPT_EMPTY + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4906
|
|
|
|
TOX_ERR_GROUP_INVITE_ACCEPT_CORE = (TOX_ERR_GROUP_INVITE_ACCEPT_PASSWORD + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4906
|
|
|
|
TOX_ERR_GROUP_INVITE_ACCEPT_FAIL_SEND = (TOX_ERR_GROUP_INVITE_ACCEPT_CORE + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 4906
|
|
|
|
Tox_Err_Group_Invite_Accept = enum_Tox_Err_Group_Invite_Accept# /usr/local/src/c-toxcore/toxcore/tox.h: 4906
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4908
|
|
if _libs["libtoxcore"].has("tox_err_group_invite_accept_to_string", "cdecl"):
|
|
tox_err_group_invite_accept_to_string = _libs["libtoxcore"].get("tox_err_group_invite_accept_to_string", "cdecl")
|
|
tox_err_group_invite_accept_to_string.argtypes = [Tox_Err_Group_Invite_Accept]
|
|
tox_err_group_invite_accept_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_group_invite_accept_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4925
|
|
if _libs["libtoxcore"].has("tox_group_invite_accept", "cdecl"):
|
|
tox_group_invite_accept = _libs["libtoxcore"].get("tox_group_invite_accept", "cdecl")
|
|
tox_group_invite_accept.argtypes = [POINTER(Tox), Tox_Friend_Number, POINTER(uint8_t), c_size_t, POINTER(uint8_t), c_size_t, POINTER(uint8_t), c_size_t, POINTER(Tox_Err_Group_Invite_Accept)]
|
|
tox_group_invite_accept.restype = Tox_Group_Number
|
|
else: LOG_ERROR("tox_group_invite_accept")
|
|
|
|
tox_group_invite_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Friend_Number, POINTER(uint8_t), c_size_t, POINTER(uint8_t), c_size_t, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 4937
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4949
|
|
if _libs["libtoxcore"].has("tox_callback_group_invite", "cdecl"):
|
|
tox_callback_group_invite = _libs["libtoxcore"].get("tox_callback_group_invite", "cdecl")
|
|
tox_callback_group_invite.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_group_invite_cb)
|
|
tox_callback_group_invite.restype = None
|
|
else: LOG_ERROR("tox_callback_group_invite")
|
|
|
|
tox_group_peer_join_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Group_Number, Tox_Group_Peer_Number, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 4956
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 4963
|
|
if _libs["libtoxcore"].has("tox_callback_group_peer_join", "cdecl"):
|
|
tox_callback_group_peer_join = _libs["libtoxcore"].get("tox_callback_group_peer_join", "cdecl")
|
|
tox_callback_group_peer_join.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_group_peer_join_cb)
|
|
tox_callback_group_peer_join.restype = None
|
|
else: LOG_ERROR("tox_callback_group_peer_join")
|
|
|
|
enum_Tox_Group_Exit_Type = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 5001
|
|
|
|
TOX_GROUP_EXIT_TYPE_QUIT = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 5001
|
|
|
|
TOX_GROUP_EXIT_TYPE_TIMEOUT = (TOX_GROUP_EXIT_TYPE_QUIT + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5001
|
|
|
|
TOX_GROUP_EXIT_TYPE_DISCONNECTED = (TOX_GROUP_EXIT_TYPE_TIMEOUT + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5001
|
|
|
|
TOX_GROUP_EXIT_TYPE_SELF_DISCONNECTED = (TOX_GROUP_EXIT_TYPE_DISCONNECTED + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5001
|
|
|
|
TOX_GROUP_EXIT_TYPE_KICK = (TOX_GROUP_EXIT_TYPE_SELF_DISCONNECTED + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5001
|
|
|
|
TOX_GROUP_EXIT_TYPE_SYNC_ERROR = (TOX_GROUP_EXIT_TYPE_KICK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5001
|
|
|
|
Tox_Group_Exit_Type = enum_Tox_Group_Exit_Type# /usr/local/src/c-toxcore/toxcore/tox.h: 5001
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 5003
|
|
if _libs["libtoxcore"].has("tox_group_exit_type_to_string", "cdecl"):
|
|
tox_group_exit_type_to_string = _libs["libtoxcore"].get("tox_group_exit_type_to_string", "cdecl")
|
|
tox_group_exit_type_to_string.argtypes = [Tox_Group_Exit_Type]
|
|
tox_group_exit_type_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_group_exit_type_to_string")
|
|
|
|
tox_group_peer_exit_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Group_Number, Tox_Group_Peer_Number, Tox_Group_Exit_Type, POINTER(uint8_t), c_size_t, POINTER(uint8_t), c_size_t, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 5015
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 5025
|
|
if _libs["libtoxcore"].has("tox_callback_group_peer_exit", "cdecl"):
|
|
tox_callback_group_peer_exit = _libs["libtoxcore"].get("tox_callback_group_peer_exit", "cdecl")
|
|
tox_callback_group_peer_exit.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_group_peer_exit_cb)
|
|
tox_callback_group_peer_exit.restype = None
|
|
else: LOG_ERROR("tox_callback_group_peer_exit")
|
|
|
|
tox_group_self_join_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Group_Number, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 5030
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 5038
|
|
if _libs["libtoxcore"].has("tox_callback_group_self_join", "cdecl"):
|
|
tox_callback_group_self_join = _libs["libtoxcore"].get("tox_callback_group_self_join", "cdecl")
|
|
tox_callback_group_self_join.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_group_self_join_cb)
|
|
tox_callback_group_self_join.restype = None
|
|
else: LOG_ERROR("tox_callback_group_self_join")
|
|
|
|
enum_Tox_Group_Join_Fail = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 5062
|
|
|
|
TOX_GROUP_JOIN_FAIL_PEER_LIMIT = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 5062
|
|
|
|
TOX_GROUP_JOIN_FAIL_INVALID_PASSWORD = (TOX_GROUP_JOIN_FAIL_PEER_LIMIT + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5062
|
|
|
|
TOX_GROUP_JOIN_FAIL_UNKNOWN = (TOX_GROUP_JOIN_FAIL_INVALID_PASSWORD + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5062
|
|
|
|
Tox_Group_Join_Fail = enum_Tox_Group_Join_Fail# /usr/local/src/c-toxcore/toxcore/tox.h: 5062
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 5064
|
|
if _libs["libtoxcore"].has("tox_group_join_fail_to_string", "cdecl"):
|
|
tox_group_join_fail_to_string = _libs["libtoxcore"].get("tox_group_join_fail_to_string", "cdecl")
|
|
tox_group_join_fail_to_string.argtypes = [Tox_Group_Join_Fail]
|
|
tox_group_join_fail_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_group_join_fail_to_string")
|
|
|
|
tox_group_join_fail_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Group_Number, Tox_Group_Join_Fail, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 5070
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 5077
|
|
if _libs["libtoxcore"].has("tox_callback_group_join_fail", "cdecl"):
|
|
tox_callback_group_join_fail = _libs["libtoxcore"].get("tox_callback_group_join_fail", "cdecl")
|
|
tox_callback_group_join_fail.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_group_join_fail_cb)
|
|
tox_callback_group_join_fail.restype = None
|
|
else: LOG_ERROR("tox_callback_group_join_fail")
|
|
|
|
enum_Tox_Err_Group_Founder_Set_Password = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 5122
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_PASSWORD_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 5122
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_PASSWORD_GROUP_NOT_FOUND = (TOX_ERR_GROUP_FOUNDER_SET_PASSWORD_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5122
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_PASSWORD_PERMISSIONS = (TOX_ERR_GROUP_FOUNDER_SET_PASSWORD_GROUP_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5122
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_PASSWORD_TOO_LONG = (TOX_ERR_GROUP_FOUNDER_SET_PASSWORD_PERMISSIONS + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5122
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_PASSWORD_FAIL_SEND = (TOX_ERR_GROUP_FOUNDER_SET_PASSWORD_TOO_LONG + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5122
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_PASSWORD_MALLOC = (TOX_ERR_GROUP_FOUNDER_SET_PASSWORD_FAIL_SEND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5122
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_PASSWORD_DISCONNECTED = (TOX_ERR_GROUP_FOUNDER_SET_PASSWORD_MALLOC + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5122
|
|
|
|
Tox_Err_Group_Founder_Set_Password = enum_Tox_Err_Group_Founder_Set_Password# /usr/local/src/c-toxcore/toxcore/tox.h: 5122
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 5124
|
|
if _libs["libtoxcore"].has("tox_err_group_founder_set_password_to_string", "cdecl"):
|
|
tox_err_group_founder_set_password_to_string = _libs["libtoxcore"].get("tox_err_group_founder_set_password_to_string", "cdecl")
|
|
tox_err_group_founder_set_password_to_string.argtypes = [Tox_Err_Group_Founder_Set_Password]
|
|
tox_err_group_founder_set_password_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_group_founder_set_password_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 5138
|
|
if _libs["libtoxcore"].has("tox_group_founder_set_password", "cdecl"):
|
|
tox_group_founder_set_password = _libs["libtoxcore"].get("tox_group_founder_set_password", "cdecl")
|
|
tox_group_founder_set_password.argtypes = [POINTER(Tox), Tox_Group_Number, POINTER(uint8_t), c_size_t, POINTER(Tox_Err_Group_Founder_Set_Password)]
|
|
tox_group_founder_set_password.restype = c_bool
|
|
else: LOG_ERROR("tox_group_founder_set_password")
|
|
|
|
enum_Tox_Err_Group_Founder_Set_Topic_Lock = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 5181
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_TOPIC_LOCK_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 5181
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_TOPIC_LOCK_GROUP_NOT_FOUND = (TOX_ERR_GROUP_FOUNDER_SET_TOPIC_LOCK_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5181
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_TOPIC_LOCK_INVALID = (TOX_ERR_GROUP_FOUNDER_SET_TOPIC_LOCK_GROUP_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5181
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_TOPIC_LOCK_PERMISSIONS = (TOX_ERR_GROUP_FOUNDER_SET_TOPIC_LOCK_INVALID + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5181
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_TOPIC_LOCK_FAIL_SET = (TOX_ERR_GROUP_FOUNDER_SET_TOPIC_LOCK_PERMISSIONS + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5181
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_TOPIC_LOCK_FAIL_SEND = (TOX_ERR_GROUP_FOUNDER_SET_TOPIC_LOCK_FAIL_SET + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5181
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_TOPIC_LOCK_DISCONNECTED = (TOX_ERR_GROUP_FOUNDER_SET_TOPIC_LOCK_FAIL_SEND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5181
|
|
|
|
Tox_Err_Group_Founder_Set_Topic_Lock = enum_Tox_Err_Group_Founder_Set_Topic_Lock# /usr/local/src/c-toxcore/toxcore/tox.h: 5181
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 5183
|
|
if _libs["libtoxcore"].has("tox_err_group_founder_set_topic_lock_to_string", "cdecl"):
|
|
tox_err_group_founder_set_topic_lock_to_string = _libs["libtoxcore"].get("tox_err_group_founder_set_topic_lock_to_string", "cdecl")
|
|
tox_err_group_founder_set_topic_lock_to_string.argtypes = [Tox_Err_Group_Founder_Set_Topic_Lock]
|
|
tox_err_group_founder_set_topic_lock_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_group_founder_set_topic_lock_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 5199
|
|
if _libs["libtoxcore"].has("tox_group_founder_set_topic_lock", "cdecl"):
|
|
tox_group_founder_set_topic_lock = _libs["libtoxcore"].get("tox_group_founder_set_topic_lock", "cdecl")
|
|
tox_group_founder_set_topic_lock.argtypes = [POINTER(Tox), Tox_Group_Number, Tox_Group_Topic_Lock, POINTER(Tox_Err_Group_Founder_Set_Topic_Lock)]
|
|
tox_group_founder_set_topic_lock.restype = c_bool
|
|
else: LOG_ERROR("tox_group_founder_set_topic_lock")
|
|
|
|
enum_Tox_Err_Group_Founder_Set_Voice_State = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 5235
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_VOICE_STATE_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 5235
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_VOICE_STATE_GROUP_NOT_FOUND = (TOX_ERR_GROUP_FOUNDER_SET_VOICE_STATE_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5235
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_VOICE_STATE_PERMISSIONS = (TOX_ERR_GROUP_FOUNDER_SET_VOICE_STATE_GROUP_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5235
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_VOICE_STATE_FAIL_SET = (TOX_ERR_GROUP_FOUNDER_SET_VOICE_STATE_PERMISSIONS + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5235
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_VOICE_STATE_FAIL_SEND = (TOX_ERR_GROUP_FOUNDER_SET_VOICE_STATE_FAIL_SET + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5235
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_VOICE_STATE_DISCONNECTED = (TOX_ERR_GROUP_FOUNDER_SET_VOICE_STATE_FAIL_SEND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5235
|
|
|
|
Tox_Err_Group_Founder_Set_Voice_State = enum_Tox_Err_Group_Founder_Set_Voice_State# /usr/local/src/c-toxcore/toxcore/tox.h: 5235
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 5237
|
|
if _libs["libtoxcore"].has("tox_err_group_founder_set_voice_state_to_string", "cdecl"):
|
|
tox_err_group_founder_set_voice_state_to_string = _libs["libtoxcore"].get("tox_err_group_founder_set_voice_state_to_string", "cdecl")
|
|
tox_err_group_founder_set_voice_state_to_string.argtypes = [Tox_Err_Group_Founder_Set_Voice_State]
|
|
tox_err_group_founder_set_voice_state_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_group_founder_set_voice_state_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 5253
|
|
if _libs["libtoxcore"].has("tox_group_founder_set_voice_state", "cdecl"):
|
|
tox_group_founder_set_voice_state = _libs["libtoxcore"].get("tox_group_founder_set_voice_state", "cdecl")
|
|
tox_group_founder_set_voice_state.argtypes = [POINTER(Tox), Tox_Group_Number, Tox_Group_Voice_State, POINTER(Tox_Err_Group_Founder_Set_Voice_State)]
|
|
tox_group_founder_set_voice_state.restype = c_bool
|
|
else: LOG_ERROR("tox_group_founder_set_voice_state")
|
|
|
|
enum_Tox_Err_Group_Founder_Set_Privacy_State = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 5289
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_PRIVACY_STATE_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 5289
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_PRIVACY_STATE_GROUP_NOT_FOUND = (TOX_ERR_GROUP_FOUNDER_SET_PRIVACY_STATE_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5289
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_PRIVACY_STATE_PERMISSIONS = (TOX_ERR_GROUP_FOUNDER_SET_PRIVACY_STATE_GROUP_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5289
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_PRIVACY_STATE_FAIL_SET = (TOX_ERR_GROUP_FOUNDER_SET_PRIVACY_STATE_PERMISSIONS + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5289
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_PRIVACY_STATE_FAIL_SEND = (TOX_ERR_GROUP_FOUNDER_SET_PRIVACY_STATE_FAIL_SET + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5289
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_PRIVACY_STATE_DISCONNECTED = (TOX_ERR_GROUP_FOUNDER_SET_PRIVACY_STATE_FAIL_SEND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5289
|
|
|
|
Tox_Err_Group_Founder_Set_Privacy_State = enum_Tox_Err_Group_Founder_Set_Privacy_State# /usr/local/src/c-toxcore/toxcore/tox.h: 5289
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 5291
|
|
if _libs["libtoxcore"].has("tox_err_group_founder_set_privacy_state_to_string", "cdecl"):
|
|
tox_err_group_founder_set_privacy_state_to_string = _libs["libtoxcore"].get("tox_err_group_founder_set_privacy_state_to_string", "cdecl")
|
|
tox_err_group_founder_set_privacy_state_to_string.argtypes = [Tox_Err_Group_Founder_Set_Privacy_State]
|
|
tox_err_group_founder_set_privacy_state_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_group_founder_set_privacy_state_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 5307
|
|
if _libs["libtoxcore"].has("tox_group_founder_set_privacy_state", "cdecl"):
|
|
tox_group_founder_set_privacy_state = _libs["libtoxcore"].get("tox_group_founder_set_privacy_state", "cdecl")
|
|
tox_group_founder_set_privacy_state.argtypes = [POINTER(Tox), Tox_Group_Number, Tox_Group_Privacy_State, POINTER(Tox_Err_Group_Founder_Set_Privacy_State)]
|
|
tox_group_founder_set_privacy_state.restype = c_bool
|
|
else: LOG_ERROR("tox_group_founder_set_privacy_state")
|
|
|
|
enum_Tox_Err_Group_Founder_Set_Peer_Limit = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 5343
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_PEER_LIMIT_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 5343
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_PEER_LIMIT_GROUP_NOT_FOUND = (TOX_ERR_GROUP_FOUNDER_SET_PEER_LIMIT_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5343
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_PEER_LIMIT_PERMISSIONS = (TOX_ERR_GROUP_FOUNDER_SET_PEER_LIMIT_GROUP_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5343
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_PEER_LIMIT_FAIL_SET = (TOX_ERR_GROUP_FOUNDER_SET_PEER_LIMIT_PERMISSIONS + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5343
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_PEER_LIMIT_FAIL_SEND = (TOX_ERR_GROUP_FOUNDER_SET_PEER_LIMIT_FAIL_SET + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5343
|
|
|
|
TOX_ERR_GROUP_FOUNDER_SET_PEER_LIMIT_DISCONNECTED = (TOX_ERR_GROUP_FOUNDER_SET_PEER_LIMIT_FAIL_SEND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5343
|
|
|
|
Tox_Err_Group_Founder_Set_Peer_Limit = enum_Tox_Err_Group_Founder_Set_Peer_Limit# /usr/local/src/c-toxcore/toxcore/tox.h: 5343
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 5345
|
|
if _libs["libtoxcore"].has("tox_err_group_founder_set_peer_limit_to_string", "cdecl"):
|
|
tox_err_group_founder_set_peer_limit_to_string = _libs["libtoxcore"].get("tox_err_group_founder_set_peer_limit_to_string", "cdecl")
|
|
tox_err_group_founder_set_peer_limit_to_string.argtypes = [Tox_Err_Group_Founder_Set_Peer_Limit]
|
|
tox_err_group_founder_set_peer_limit_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_group_founder_set_peer_limit_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 5358
|
|
if _libs["libtoxcore"].has("tox_group_founder_set_peer_limit", "cdecl"):
|
|
tox_group_founder_set_peer_limit = _libs["libtoxcore"].get("tox_group_founder_set_peer_limit", "cdecl")
|
|
tox_group_founder_set_peer_limit.argtypes = [POINTER(Tox), Tox_Group_Number, uint16_t, POINTER(Tox_Err_Group_Founder_Set_Peer_Limit)]
|
|
tox_group_founder_set_peer_limit.restype = c_bool
|
|
else: LOG_ERROR("tox_group_founder_set_peer_limit")
|
|
|
|
enum_Tox_Err_Group_Set_Ignore = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 5389
|
|
|
|
TOX_ERR_GROUP_SET_IGNORE_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 5389
|
|
|
|
TOX_ERR_GROUP_SET_IGNORE_GROUP_NOT_FOUND = (TOX_ERR_GROUP_SET_IGNORE_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5389
|
|
|
|
TOX_ERR_GROUP_SET_IGNORE_PEER_NOT_FOUND = (TOX_ERR_GROUP_SET_IGNORE_GROUP_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5389
|
|
|
|
TOX_ERR_GROUP_SET_IGNORE_SELF = (TOX_ERR_GROUP_SET_IGNORE_PEER_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5389
|
|
|
|
Tox_Err_Group_Set_Ignore = enum_Tox_Err_Group_Set_Ignore# /usr/local/src/c-toxcore/toxcore/tox.h: 5389
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 5391
|
|
if _libs["libtoxcore"].has("tox_err_group_set_ignore_to_string", "cdecl"):
|
|
tox_err_group_set_ignore_to_string = _libs["libtoxcore"].get("tox_err_group_set_ignore_to_string", "cdecl")
|
|
tox_err_group_set_ignore_to_string.argtypes = [Tox_Err_Group_Set_Ignore]
|
|
tox_err_group_set_ignore_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_group_set_ignore_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 5402
|
|
if _libs["libtoxcore"].has("tox_group_set_ignore", "cdecl"):
|
|
tox_group_set_ignore = _libs["libtoxcore"].get("tox_group_set_ignore", "cdecl")
|
|
tox_group_set_ignore.argtypes = [POINTER(Tox), Tox_Group_Number, Tox_Group_Peer_Number, c_bool, POINTER(Tox_Err_Group_Set_Ignore)]
|
|
tox_group_set_ignore.restype = c_bool
|
|
else: LOG_ERROR("tox_group_set_ignore")
|
|
|
|
enum_Tox_Err_Group_Mod_Set_Role = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 5444
|
|
|
|
TOX_ERR_GROUP_MOD_SET_ROLE_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 5444
|
|
|
|
TOX_ERR_GROUP_MOD_SET_ROLE_GROUP_NOT_FOUND = (TOX_ERR_GROUP_MOD_SET_ROLE_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5444
|
|
|
|
TOX_ERR_GROUP_MOD_SET_ROLE_PEER_NOT_FOUND = (TOX_ERR_GROUP_MOD_SET_ROLE_GROUP_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5444
|
|
|
|
TOX_ERR_GROUP_MOD_SET_ROLE_PERMISSIONS = (TOX_ERR_GROUP_MOD_SET_ROLE_PEER_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5444
|
|
|
|
TOX_ERR_GROUP_MOD_SET_ROLE_ASSIGNMENT = (TOX_ERR_GROUP_MOD_SET_ROLE_PERMISSIONS + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5444
|
|
|
|
TOX_ERR_GROUP_MOD_SET_ROLE_FAIL_ACTION = (TOX_ERR_GROUP_MOD_SET_ROLE_ASSIGNMENT + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5444
|
|
|
|
TOX_ERR_GROUP_MOD_SET_ROLE_SELF = (TOX_ERR_GROUP_MOD_SET_ROLE_FAIL_ACTION + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5444
|
|
|
|
Tox_Err_Group_Mod_Set_Role = enum_Tox_Err_Group_Mod_Set_Role# /usr/local/src/c-toxcore/toxcore/tox.h: 5444
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 5446
|
|
if _libs["libtoxcore"].has("tox_err_group_mod_set_role_to_string", "cdecl"):
|
|
tox_err_group_mod_set_role_to_string = _libs["libtoxcore"].get("tox_err_group_mod_set_role_to_string", "cdecl")
|
|
tox_err_group_mod_set_role_to_string.argtypes = [Tox_Err_Group_Mod_Set_Role]
|
|
tox_err_group_mod_set_role_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_group_mod_set_role_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 5461
|
|
if _libs["libtoxcore"].has("tox_group_mod_set_role", "cdecl"):
|
|
tox_group_mod_set_role = _libs["libtoxcore"].get("tox_group_mod_set_role", "cdecl")
|
|
tox_group_mod_set_role.argtypes = [POINTER(Tox), Tox_Group_Number, Tox_Group_Peer_Number, Tox_Group_Role, POINTER(Tox_Err_Group_Mod_Set_Role)]
|
|
tox_group_mod_set_role.restype = c_bool
|
|
else: LOG_ERROR("tox_group_mod_set_role")
|
|
|
|
enum_Tox_Err_Group_Mod_Kick_Peer = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 5501
|
|
|
|
TOX_ERR_GROUP_MOD_KICK_PEER_OK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 5501
|
|
|
|
TOX_ERR_GROUP_MOD_KICK_PEER_GROUP_NOT_FOUND = (TOX_ERR_GROUP_MOD_KICK_PEER_OK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5501
|
|
|
|
TOX_ERR_GROUP_MOD_KICK_PEER_PEER_NOT_FOUND = (TOX_ERR_GROUP_MOD_KICK_PEER_GROUP_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5501
|
|
|
|
TOX_ERR_GROUP_MOD_KICK_PEER_PERMISSIONS = (TOX_ERR_GROUP_MOD_KICK_PEER_PEER_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5501
|
|
|
|
TOX_ERR_GROUP_MOD_KICK_PEER_FAIL_ACTION = (TOX_ERR_GROUP_MOD_KICK_PEER_PERMISSIONS + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5501
|
|
|
|
TOX_ERR_GROUP_MOD_KICK_PEER_FAIL_SEND = (TOX_ERR_GROUP_MOD_KICK_PEER_FAIL_ACTION + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5501
|
|
|
|
TOX_ERR_GROUP_MOD_KICK_PEER_SELF = (TOX_ERR_GROUP_MOD_KICK_PEER_FAIL_SEND + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5501
|
|
|
|
Tox_Err_Group_Mod_Kick_Peer = enum_Tox_Err_Group_Mod_Kick_Peer# /usr/local/src/c-toxcore/toxcore/tox.h: 5501
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 5503
|
|
if _libs["libtoxcore"].has("tox_err_group_mod_kick_peer_to_string", "cdecl"):
|
|
tox_err_group_mod_kick_peer_to_string = _libs["libtoxcore"].get("tox_err_group_mod_kick_peer_to_string", "cdecl")
|
|
tox_err_group_mod_kick_peer_to_string.argtypes = [Tox_Err_Group_Mod_Kick_Peer]
|
|
tox_err_group_mod_kick_peer_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_err_group_mod_kick_peer_to_string")
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 5517
|
|
if _libs["libtoxcore"].has("tox_group_mod_kick_peer", "cdecl"):
|
|
tox_group_mod_kick_peer = _libs["libtoxcore"].get("tox_group_mod_kick_peer", "cdecl")
|
|
tox_group_mod_kick_peer.argtypes = [POINTER(Tox), Tox_Group_Number, Tox_Group_Peer_Number, POINTER(Tox_Err_Group_Mod_Kick_Peer)]
|
|
tox_group_mod_kick_peer.restype = c_bool
|
|
else: LOG_ERROR("tox_group_mod_kick_peer")
|
|
|
|
enum_Tox_Group_Mod_Event = c_int# /usr/local/src/c-toxcore/toxcore/tox.h: 5545
|
|
|
|
TOX_GROUP_MOD_EVENT_KICK = 0# /usr/local/src/c-toxcore/toxcore/tox.h: 5545
|
|
|
|
TOX_GROUP_MOD_EVENT_OBSERVER = (TOX_GROUP_MOD_EVENT_KICK + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5545
|
|
|
|
TOX_GROUP_MOD_EVENT_USER = (TOX_GROUP_MOD_EVENT_OBSERVER + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5545
|
|
|
|
TOX_GROUP_MOD_EVENT_MODERATOR = (TOX_GROUP_MOD_EVENT_USER + 1)# /usr/local/src/c-toxcore/toxcore/tox.h: 5545
|
|
|
|
Tox_Group_Mod_Event = enum_Tox_Group_Mod_Event# /usr/local/src/c-toxcore/toxcore/tox.h: 5545
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 5547
|
|
if _libs["libtoxcore"].has("tox_group_mod_event_to_string", "cdecl"):
|
|
tox_group_mod_event_to_string = _libs["libtoxcore"].get("tox_group_mod_event_to_string", "cdecl")
|
|
tox_group_mod_event_to_string.argtypes = [Tox_Group_Mod_Event]
|
|
tox_group_mod_event_to_string.restype = c_char_p
|
|
else: LOG_ERROR("tox_group_mod_event_to_string")
|
|
|
|
tox_group_moderation_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), Tox_Group_Number, Tox_Group_Peer_Number, Tox_Group_Peer_Number, Tox_Group_Mod_Event, POINTER(None))# /usr/local/src/c-toxcore/toxcore/tox.h: 5555
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 5569
|
|
if _libs["libtoxcore"].has("tox_callback_group_moderation", "cdecl"):
|
|
tox_callback_group_moderation = _libs["libtoxcore"].get("tox_callback_group_moderation", "cdecl")
|
|
tox_callback_group_moderation.argtypes = [POINTER(Tox), UNCHECKED(None)] # POINTER(tox_group_moderation_cb)
|
|
tox_callback_group_moderation.restype = None
|
|
else: LOG_ERROR("tox_callback_group_moderation")
|
|
|
|
TOX_ERR_OPTIONS_NEW = Tox_Err_Options_New# /usr/local/src/c-toxcore/toxcore/tox.h: 5582
|
|
|
|
TOX_ERR_NEW = Tox_Err_New# /usr/local/src/c-toxcore/toxcore/tox.h: 5583
|
|
|
|
TOX_ERR_BOOTSTRAP = Tox_Err_Bootstrap# /usr/local/src/c-toxcore/toxcore/tox.h: 5584
|
|
|
|
TOX_ERR_SET_INFO = Tox_Err_Set_Info# /usr/local/src/c-toxcore/toxcore/tox.h: 5585
|
|
|
|
TOX_ERR_FRIEND_ADD = Tox_Err_Friend_Add# /usr/local/src/c-toxcore/toxcore/tox.h: 5586
|
|
|
|
TOX_ERR_FRIEND_DELETE = Tox_Err_Friend_Delete# /usr/local/src/c-toxcore/toxcore/tox.h: 5587
|
|
|
|
TOX_ERR_FRIEND_BY_PUBLIC_KEY = Tox_Err_Friend_By_Public_Key# /usr/local/src/c-toxcore/toxcore/tox.h: 5588
|
|
|
|
TOX_ERR_FRIEND_GET_PUBLIC_KEY = Tox_Err_Friend_Get_Public_Key# /usr/local/src/c-toxcore/toxcore/tox.h: 5589
|
|
|
|
TOX_ERR_FRIEND_GET_LAST_ONLINE = Tox_Err_Friend_Get_Last_Online# /usr/local/src/c-toxcore/toxcore/tox.h: 5590
|
|
|
|
TOX_ERR_FRIEND_QUERY = Tox_Err_Friend_Query# /usr/local/src/c-toxcore/toxcore/tox.h: 5591
|
|
|
|
TOX_ERR_SET_TYPING = Tox_Err_Set_Typing# /usr/local/src/c-toxcore/toxcore/tox.h: 5592
|
|
|
|
TOX_ERR_FRIEND_SEND_MESSAGE = Tox_Err_Friend_Send_Message# /usr/local/src/c-toxcore/toxcore/tox.h: 5593
|
|
|
|
TOX_ERR_FILE_CONTROL = Tox_Err_File_Control# /usr/local/src/c-toxcore/toxcore/tox.h: 5594
|
|
|
|
TOX_ERR_FILE_SEEK = Tox_Err_File_Seek# /usr/local/src/c-toxcore/toxcore/tox.h: 5595
|
|
|
|
TOX_ERR_FILE_GET = Tox_Err_File_Get# /usr/local/src/c-toxcore/toxcore/tox.h: 5596
|
|
|
|
TOX_ERR_FILE_SEND = Tox_Err_File_Send# /usr/local/src/c-toxcore/toxcore/tox.h: 5597
|
|
|
|
TOX_ERR_FILE_SEND_CHUNK = Tox_Err_File_Send_Chunk# /usr/local/src/c-toxcore/toxcore/tox.h: 5598
|
|
|
|
TOX_ERR_CONFERENCE_NEW = Tox_Err_Conference_New# /usr/local/src/c-toxcore/toxcore/tox.h: 5599
|
|
|
|
TOX_ERR_CONFERENCE_DELETE = Tox_Err_Conference_Delete# /usr/local/src/c-toxcore/toxcore/tox.h: 5600
|
|
|
|
TOX_ERR_CONFERENCE_PEER_QUERY = Tox_Err_Conference_Peer_Query# /usr/local/src/c-toxcore/toxcore/tox.h: 5601
|
|
|
|
TOX_ERR_CONFERENCE_SET_MAX_OFFLINE = Tox_Err_Conference_Set_Max_Offline# /usr/local/src/c-toxcore/toxcore/tox.h: 5602
|
|
|
|
TOX_ERR_CONFERENCE_BY_ID = Tox_Err_Conference_By_Id# /usr/local/src/c-toxcore/toxcore/tox.h: 5603
|
|
|
|
TOX_ERR_CONFERENCE_BY_UID = Tox_Err_Conference_By_Uid# /usr/local/src/c-toxcore/toxcore/tox.h: 5604
|
|
|
|
TOX_ERR_CONFERENCE_INVITE = Tox_Err_Conference_Invite# /usr/local/src/c-toxcore/toxcore/tox.h: 5605
|
|
|
|
TOX_ERR_CONFERENCE_JOIN = Tox_Err_Conference_Join# /usr/local/src/c-toxcore/toxcore/tox.h: 5606
|
|
|
|
TOX_ERR_CONFERENCE_SEND_MESSAGE = Tox_Err_Conference_Send_Message# /usr/local/src/c-toxcore/toxcore/tox.h: 5607
|
|
|
|
TOX_ERR_CONFERENCE_TITLE = Tox_Err_Conference_Title# /usr/local/src/c-toxcore/toxcore/tox.h: 5608
|
|
|
|
TOX_ERR_CONFERENCE_GET_TYPE = Tox_Err_Conference_Get_Type# /usr/local/src/c-toxcore/toxcore/tox.h: 5609
|
|
|
|
TOX_ERR_FRIEND_CUSTOM_PACKET = Tox_Err_Friend_Custom_Packet# /usr/local/src/c-toxcore/toxcore/tox.h: 5610
|
|
|
|
TOX_ERR_GET_PORT = Tox_Err_Get_Port# /usr/local/src/c-toxcore/toxcore/tox.h: 5611
|
|
|
|
TOX_USER_STATUS = Tox_User_Status# /usr/local/src/c-toxcore/toxcore/tox.h: 5612
|
|
|
|
TOX_MESSAGE_TYPE = Tox_Message_Type# /usr/local/src/c-toxcore/toxcore/tox.h: 5613
|
|
|
|
TOX_PROXY_TYPE = Tox_Proxy_Type# /usr/local/src/c-toxcore/toxcore/tox.h: 5614
|
|
|
|
TOX_SAVEDATA_TYPE = Tox_Savedata_Type# /usr/local/src/c-toxcore/toxcore/tox.h: 5615
|
|
|
|
TOX_LOG_LEVEL = Tox_Log_Level# /usr/local/src/c-toxcore/toxcore/tox.h: 5616
|
|
|
|
TOX_CONNECTION = Tox_Connection# /usr/local/src/c-toxcore/toxcore/tox.h: 5617
|
|
|
|
TOX_FILE_CONTROL = Tox_File_Control# /usr/local/src/c-toxcore/toxcore/tox.h: 5618
|
|
|
|
TOX_CONFERENCE_TYPE = Tox_Conference_Type# /usr/local/src/c-toxcore/toxcore/tox.h: 5619
|
|
|
|
TOX_FILE_KIND = enum_Tox_File_Kind# /usr/local/src/c-toxcore/toxcore/tox.h: 5620
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 84
|
|
class struct_ToxAV(Structure):
|
|
pass
|
|
|
|
ToxAV = struct_ToxAV# /usr/local/src/c-toxcore/toxav/toxav.h: 84
|
|
|
|
enum_Toxav_Err_New = c_int# /usr/local/src/c-toxcore/toxav/toxav.h: 113
|
|
|
|
TOXAV_ERR_NEW_OK = 0# /usr/local/src/c-toxcore/toxav/toxav.h: 113
|
|
|
|
TOXAV_ERR_NEW_NULL = (TOXAV_ERR_NEW_OK + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 113
|
|
|
|
TOXAV_ERR_NEW_MALLOC = (TOXAV_ERR_NEW_NULL + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 113
|
|
|
|
TOXAV_ERR_NEW_MULTIPLE = (TOXAV_ERR_NEW_MALLOC + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 113
|
|
|
|
Toxav_Err_New = enum_Toxav_Err_New# /usr/local/src/c-toxcore/toxav/toxav.h: 113
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 118
|
|
if _libs["libtoxcore"].has("toxav_new", "cdecl"):
|
|
toxav_new = _libs["libtoxcore"].get("toxav_new", "cdecl")
|
|
toxav_new.argtypes = [POINTER(Tox), POINTER(Toxav_Err_New)]
|
|
toxav_new.restype = POINTER(ToxAV)
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 127
|
|
if _libs["libtoxcore"].has("toxav_kill", "cdecl"):
|
|
toxav_kill = _libs["libtoxcore"].get("toxav_kill", "cdecl")
|
|
toxav_kill.argtypes = [POINTER(ToxAV)]
|
|
toxav_kill.restype = None
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 132
|
|
if _libs["libtoxcore"].has("toxav_get_tox", "cdecl"):
|
|
toxav_get_tox = _libs["libtoxcore"].get("toxav_get_tox", "cdecl")
|
|
toxav_get_tox.argtypes = [POINTER(ToxAV)]
|
|
toxav_get_tox.restype = POINTER(Tox)
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 145
|
|
if _libs["libtoxcore"].has("toxav_iteration_interval", "cdecl"):
|
|
toxav_iteration_interval = _libs["libtoxcore"].get("toxav_iteration_interval", "cdecl")
|
|
toxav_iteration_interval.argtypes = [POINTER(ToxAV)]
|
|
toxav_iteration_interval.restype = uint32_t
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 152
|
|
if _libs["libtoxcore"].has("toxav_iterate", "cdecl"):
|
|
toxav_iterate = _libs["libtoxcore"].get("toxav_iterate", "cdecl")
|
|
toxav_iterate.argtypes = [POINTER(ToxAV)]
|
|
toxav_iterate.restype = None
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 165
|
|
if _libs["libtoxcore"].has("toxav_audio_iteration_interval", "cdecl"):
|
|
toxav_audio_iteration_interval = _libs["libtoxcore"].get("toxav_audio_iteration_interval", "cdecl")
|
|
toxav_audio_iteration_interval.argtypes = [POINTER(ToxAV)]
|
|
toxav_audio_iteration_interval.restype = uint32_t
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 174
|
|
if _libs["libtoxcore"].has("toxav_audio_iterate", "cdecl"):
|
|
toxav_audio_iterate = _libs["libtoxcore"].get("toxav_audio_iterate", "cdecl")
|
|
toxav_audio_iterate.argtypes = [POINTER(ToxAV)]
|
|
toxav_audio_iterate.restype = None
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 181
|
|
if _libs["libtoxcore"].has("toxav_video_iteration_interval", "cdecl"):
|
|
toxav_video_iteration_interval = _libs["libtoxcore"].get("toxav_video_iteration_interval", "cdecl")
|
|
toxav_video_iteration_interval.argtypes = [POINTER(ToxAV)]
|
|
toxav_video_iteration_interval.restype = uint32_t
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 190
|
|
if _libs["libtoxcore"].has("toxav_video_iterate", "cdecl"):
|
|
toxav_video_iterate = _libs["libtoxcore"].get("toxav_video_iterate", "cdecl")
|
|
toxav_video_iterate.argtypes = [POINTER(ToxAV)]
|
|
toxav_video_iterate.restype = None
|
|
|
|
enum_Toxav_Err_Call = c_int# /usr/local/src/c-toxcore/toxav/toxav.h: 237
|
|
|
|
TOXAV_ERR_CALL_OK = 0# /usr/local/src/c-toxcore/toxav/toxav.h: 237
|
|
|
|
TOXAV_ERR_CALL_MALLOC = (TOXAV_ERR_CALL_OK + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 237
|
|
|
|
TOXAV_ERR_CALL_SYNC = (TOXAV_ERR_CALL_MALLOC + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 237
|
|
|
|
TOXAV_ERR_CALL_FRIEND_NOT_FOUND = (TOXAV_ERR_CALL_SYNC + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 237
|
|
|
|
TOXAV_ERR_CALL_FRIEND_NOT_CONNECTED = (TOXAV_ERR_CALL_FRIEND_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 237
|
|
|
|
TOXAV_ERR_CALL_FRIEND_ALREADY_IN_CALL = (TOXAV_ERR_CALL_FRIEND_NOT_CONNECTED + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 237
|
|
|
|
TOXAV_ERR_CALL_INVALID_BIT_RATE = (TOXAV_ERR_CALL_FRIEND_ALREADY_IN_CALL + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 237
|
|
|
|
Toxav_Err_Call = enum_Toxav_Err_Call# /usr/local/src/c-toxcore/toxav/toxav.h: 237
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 253
|
|
if _libs["libtoxcore"].has("toxav_call", "cdecl"):
|
|
toxav_call = _libs["libtoxcore"].get("toxav_call", "cdecl")
|
|
toxav_call.argtypes = [POINTER(ToxAV), uint32_t, uint32_t, uint32_t, POINTER(Toxav_Err_Call)]
|
|
toxav_call.restype = c_bool
|
|
|
|
toxav_call_cb = CFUNCTYPE(UNCHECKED(None), POINTER(ToxAV), uint32_t, c_bool, c_bool, POINTER(None))# /usr/local/src/c-toxcore/toxav/toxav.h: 263
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 269
|
|
if _libs["libtoxcore"].has("toxav_callback_call", "cdecl"):
|
|
toxav_callback_call = _libs["libtoxcore"].get("toxav_callback_call", "cdecl")
|
|
toxav_callback_call.argtypes = [POINTER(ToxAV), POINTER(toxav_call_cb), POINTER(None)]
|
|
toxav_callback_call.restype = None
|
|
|
|
enum_Toxav_Err_Answer = c_int# /usr/local/src/c-toxcore/toxav/toxav.h: 306
|
|
|
|
TOXAV_ERR_ANSWER_OK = 0# /usr/local/src/c-toxcore/toxav/toxav.h: 306
|
|
|
|
TOXAV_ERR_ANSWER_SYNC = (TOXAV_ERR_ANSWER_OK + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 306
|
|
|
|
TOXAV_ERR_ANSWER_CODEC_INITIALIZATION = (TOXAV_ERR_ANSWER_SYNC + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 306
|
|
|
|
TOXAV_ERR_ANSWER_FRIEND_NOT_FOUND = (TOXAV_ERR_ANSWER_CODEC_INITIALIZATION + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 306
|
|
|
|
TOXAV_ERR_ANSWER_FRIEND_NOT_CALLING = (TOXAV_ERR_ANSWER_FRIEND_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 306
|
|
|
|
TOXAV_ERR_ANSWER_INVALID_BIT_RATE = (TOXAV_ERR_ANSWER_FRIEND_NOT_CALLING + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 306
|
|
|
|
Toxav_Err_Answer = enum_Toxav_Err_Answer# /usr/local/src/c-toxcore/toxav/toxav.h: 306
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 321
|
|
if _libs["libtoxcore"].has("toxav_answer", "cdecl"):
|
|
toxav_answer = _libs["libtoxcore"].get("toxav_answer", "cdecl")
|
|
toxav_answer.argtypes = [POINTER(ToxAV), uint32_t, uint32_t, uint32_t, POINTER(Toxav_Err_Answer)]
|
|
toxav_answer.restype = c_bool
|
|
|
|
enum_Toxav_Friend_Call_State = c_int# /usr/local/src/c-toxcore/toxav/toxav.h: 330
|
|
|
|
TOXAV_FRIEND_CALL_STATE_NONE = 0# /usr/local/src/c-toxcore/toxav/toxav.h: 330
|
|
|
|
TOXAV_FRIEND_CALL_STATE_ERROR = 1# /usr/local/src/c-toxcore/toxav/toxav.h: 330
|
|
|
|
TOXAV_FRIEND_CALL_STATE_FINISHED = 2# /usr/local/src/c-toxcore/toxav/toxav.h: 330
|
|
|
|
TOXAV_FRIEND_CALL_STATE_SENDING_A = 4# /usr/local/src/c-toxcore/toxav/toxav.h: 330
|
|
|
|
TOXAV_FRIEND_CALL_STATE_SENDING_V = 8# /usr/local/src/c-toxcore/toxav/toxav.h: 330
|
|
|
|
TOXAV_FRIEND_CALL_STATE_ACCEPTING_A = 16# /usr/local/src/c-toxcore/toxav/toxav.h: 330
|
|
|
|
TOXAV_FRIEND_CALL_STATE_ACCEPTING_V = 32# /usr/local/src/c-toxcore/toxav/toxav.h: 330
|
|
|
|
toxav_call_state_cb = CFUNCTYPE(UNCHECKED(None), POINTER(ToxAV), uint32_t, uint32_t, POINTER(None))# /usr/local/src/c-toxcore/toxav/toxav.h: 383
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 389
|
|
if _libs["libtoxcore"].has("toxav_callback_call_state", "cdecl"):
|
|
toxav_callback_call_state = _libs["libtoxcore"].get("toxav_callback_call_state", "cdecl")
|
|
toxav_callback_call_state.argtypes = [POINTER(ToxAV), POINTER(toxav_call_state_cb), POINTER(None)]
|
|
toxav_callback_call_state.restype = None
|
|
|
|
enum_Toxav_Call_Control = c_int# /usr/local/src/c-toxcore/toxav/toxav.h: 440
|
|
|
|
TOXAV_CALL_CONTROL_RESUME = 0# /usr/local/src/c-toxcore/toxav/toxav.h: 440
|
|
|
|
TOXAV_CALL_CONTROL_PAUSE = (TOXAV_CALL_CONTROL_RESUME + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 440
|
|
|
|
TOXAV_CALL_CONTROL_CANCEL = (TOXAV_CALL_CONTROL_PAUSE + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 440
|
|
|
|
TOXAV_CALL_CONTROL_MUTE_AUDIO = (TOXAV_CALL_CONTROL_CANCEL + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 440
|
|
|
|
TOXAV_CALL_CONTROL_UNMUTE_AUDIO = (TOXAV_CALL_CONTROL_MUTE_AUDIO + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 440
|
|
|
|
TOXAV_CALL_CONTROL_HIDE_VIDEO = (TOXAV_CALL_CONTROL_UNMUTE_AUDIO + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 440
|
|
|
|
TOXAV_CALL_CONTROL_SHOW_VIDEO = (TOXAV_CALL_CONTROL_HIDE_VIDEO + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 440
|
|
|
|
Toxav_Call_Control = enum_Toxav_Call_Control# /usr/local/src/c-toxcore/toxav/toxav.h: 440
|
|
|
|
enum_Toxav_Err_Call_Control = c_int# /usr/local/src/c-toxcore/toxav/toxav.h: 471
|
|
|
|
TOXAV_ERR_CALL_CONTROL_OK = 0# /usr/local/src/c-toxcore/toxav/toxav.h: 471
|
|
|
|
TOXAV_ERR_CALL_CONTROL_SYNC = (TOXAV_ERR_CALL_CONTROL_OK + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 471
|
|
|
|
TOXAV_ERR_CALL_CONTROL_FRIEND_NOT_FOUND = (TOXAV_ERR_CALL_CONTROL_SYNC + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 471
|
|
|
|
TOXAV_ERR_CALL_CONTROL_FRIEND_NOT_IN_CALL = (TOXAV_ERR_CALL_CONTROL_FRIEND_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 471
|
|
|
|
TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION = (TOXAV_ERR_CALL_CONTROL_FRIEND_NOT_IN_CALL + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 471
|
|
|
|
Toxav_Err_Call_Control = enum_Toxav_Err_Call_Control# /usr/local/src/c-toxcore/toxav/toxav.h: 471
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 482
|
|
if _libs["libtoxcore"].has("toxav_call_control", "cdecl"):
|
|
toxav_call_control = _libs["libtoxcore"].get("toxav_call_control", "cdecl")
|
|
toxav_call_control.argtypes = [POINTER(ToxAV), uint32_t, Toxav_Call_Control, POINTER(Toxav_Err_Call_Control)]
|
|
toxav_call_control.restype = c_bool
|
|
|
|
enum_Toxav_Err_Bit_Rate_Set = c_int# /usr/local/src/c-toxcore/toxav/toxav.h: 517
|
|
|
|
TOXAV_ERR_BIT_RATE_SET_OK = 0# /usr/local/src/c-toxcore/toxav/toxav.h: 517
|
|
|
|
TOXAV_ERR_BIT_RATE_SET_SYNC = (TOXAV_ERR_BIT_RATE_SET_OK + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 517
|
|
|
|
TOXAV_ERR_BIT_RATE_SET_INVALID_BIT_RATE = (TOXAV_ERR_BIT_RATE_SET_SYNC + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 517
|
|
|
|
TOXAV_ERR_BIT_RATE_SET_FRIEND_NOT_FOUND = (TOXAV_ERR_BIT_RATE_SET_INVALID_BIT_RATE + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 517
|
|
|
|
TOXAV_ERR_BIT_RATE_SET_FRIEND_NOT_IN_CALL = (TOXAV_ERR_BIT_RATE_SET_FRIEND_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 517
|
|
|
|
Toxav_Err_Bit_Rate_Set = enum_Toxav_Err_Bit_Rate_Set# /usr/local/src/c-toxcore/toxav/toxav.h: 517
|
|
|
|
enum_Toxav_Err_Send_Frame = c_int# /usr/local/src/c-toxcore/toxav/toxav.h: 570
|
|
|
|
TOXAV_ERR_SEND_FRAME_OK = 0# /usr/local/src/c-toxcore/toxav/toxav.h: 570
|
|
|
|
TOXAV_ERR_SEND_FRAME_NULL = (TOXAV_ERR_SEND_FRAME_OK + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 570
|
|
|
|
TOXAV_ERR_SEND_FRAME_FRIEND_NOT_FOUND = (TOXAV_ERR_SEND_FRAME_NULL + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 570
|
|
|
|
TOXAV_ERR_SEND_FRAME_FRIEND_NOT_IN_CALL = (TOXAV_ERR_SEND_FRAME_FRIEND_NOT_FOUND + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 570
|
|
|
|
TOXAV_ERR_SEND_FRAME_SYNC = (TOXAV_ERR_SEND_FRAME_FRIEND_NOT_IN_CALL + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 570
|
|
|
|
TOXAV_ERR_SEND_FRAME_INVALID = (TOXAV_ERR_SEND_FRAME_SYNC + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 570
|
|
|
|
TOXAV_ERR_SEND_FRAME_PAYLOAD_TYPE_DISABLED = (TOXAV_ERR_SEND_FRAME_INVALID + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 570
|
|
|
|
TOXAV_ERR_SEND_FRAME_RTP_FAILED = (TOXAV_ERR_SEND_FRAME_PAYLOAD_TYPE_DISABLED + 1)# /usr/local/src/c-toxcore/toxav/toxav.h: 570
|
|
|
|
Toxav_Err_Send_Frame = enum_Toxav_Err_Send_Frame# /usr/local/src/c-toxcore/toxav/toxav.h: 570
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 592
|
|
if _libs["libtoxcore"].has("toxav_audio_send_frame", "cdecl"):
|
|
toxav_audio_send_frame = _libs["libtoxcore"].get("toxav_audio_send_frame", "cdecl")
|
|
toxav_audio_send_frame.argtypes = [POINTER(ToxAV), uint32_t, POINTER(c_int16), c_size_t, uint8_t, uint32_t, POINTER(Toxav_Err_Send_Frame)]
|
|
toxav_audio_send_frame.restype = c_bool
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 604
|
|
if _libs["libtoxcore"].has("toxav_audio_set_bit_rate", "cdecl"):
|
|
toxav_audio_set_bit_rate = _libs["libtoxcore"].get("toxav_audio_set_bit_rate", "cdecl")
|
|
toxav_audio_set_bit_rate.argtypes = [POINTER(ToxAV), uint32_t, uint32_t, POINTER(Toxav_Err_Bit_Rate_Set)]
|
|
toxav_audio_set_bit_rate.restype = c_bool
|
|
|
|
toxav_audio_bit_rate_cb = CFUNCTYPE(UNCHECKED(None), POINTER(ToxAV), uint32_t, uint32_t, POINTER(None))# /usr/local/src/c-toxcore/toxav/toxav.h: 615
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 621
|
|
if _libs["libtoxcore"].has("toxav_callback_audio_bit_rate", "cdecl"):
|
|
toxav_callback_audio_bit_rate = _libs["libtoxcore"].get("toxav_callback_audio_bit_rate", "cdecl")
|
|
toxav_callback_audio_bit_rate.argtypes = [POINTER(ToxAV), POINTER(toxav_audio_bit_rate_cb), POINTER(None)]
|
|
toxav_callback_audio_bit_rate.restype = None
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 638
|
|
if _libs["libtoxcore"].has("toxav_video_send_frame", "cdecl"):
|
|
toxav_video_send_frame = _libs["libtoxcore"].get("toxav_video_send_frame", "cdecl")
|
|
toxav_video_send_frame.argtypes = [POINTER(ToxAV), uint32_t, uint16_t, uint16_t, POINTER(uint8_t), POINTER(uint8_t), POINTER(uint8_t), POINTER(Toxav_Err_Send_Frame)]
|
|
toxav_video_send_frame.restype = c_bool
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 654
|
|
if _libs["libtoxcore"].has("toxav_video_set_bit_rate", "cdecl"):
|
|
toxav_video_set_bit_rate = _libs["libtoxcore"].get("toxav_video_set_bit_rate", "cdecl")
|
|
toxav_video_set_bit_rate.argtypes = [POINTER(ToxAV), uint32_t, uint32_t, POINTER(Toxav_Err_Bit_Rate_Set)]
|
|
toxav_video_set_bit_rate.restype = c_bool
|
|
|
|
toxav_video_bit_rate_cb = CFUNCTYPE(UNCHECKED(None), POINTER(ToxAV), uint32_t, uint32_t, POINTER(None))# /usr/local/src/c-toxcore/toxav/toxav.h: 665
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 671
|
|
if _libs["libtoxcore"].has("toxav_callback_video_bit_rate", "cdecl"):
|
|
toxav_callback_video_bit_rate = _libs["libtoxcore"].get("toxav_callback_video_bit_rate", "cdecl")
|
|
toxav_callback_video_bit_rate.argtypes = [POINTER(ToxAV), POINTER(toxav_video_bit_rate_cb), POINTER(None)]
|
|
toxav_callback_video_bit_rate.restype = None
|
|
|
|
toxav_audio_receive_frame_cb = CFUNCTYPE(UNCHECKED(None), POINTER(ToxAV), uint32_t, POINTER(c_int16), c_size_t, uint8_t, uint32_t, POINTER(None))# /usr/local/src/c-toxcore/toxav/toxav.h: 691
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 698
|
|
if _libs["libtoxcore"].has("toxav_callback_audio_receive_frame", "cdecl"):
|
|
toxav_callback_audio_receive_frame = _libs["libtoxcore"].get("toxav_callback_audio_receive_frame", "cdecl")
|
|
toxav_callback_audio_receive_frame.argtypes = [POINTER(ToxAV), POINTER(toxav_audio_receive_frame_cb), POINTER(None)]
|
|
toxav_callback_audio_receive_frame.restype = None
|
|
|
|
toxav_video_receive_frame_cb = CFUNCTYPE(UNCHECKED(None), POINTER(ToxAV), uint32_t, uint16_t, uint16_t, POINTER(uint8_t), POINTER(uint8_t), POINTER(uint8_t), c_int32, c_int32, c_int32, POINTER(None))# /usr/local/src/c-toxcore/toxav/toxav.h: 722
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 735
|
|
if _libs["libtoxcore"].has("toxav_callback_video_receive_frame", "cdecl"):
|
|
toxav_callback_video_receive_frame = _libs["libtoxcore"].get("toxav_callback_video_receive_frame", "cdecl")
|
|
toxav_callback_video_receive_frame.argtypes = [POINTER(ToxAV), POINTER(toxav_video_receive_frame_cb), POINTER(None)]
|
|
toxav_callback_video_receive_frame.restype = None
|
|
|
|
toxav_group_audio_cb = CFUNCTYPE(UNCHECKED(None), POINTER(Tox), uint32_t, uint32_t, POINTER(c_int16), uint32_t, uint8_t, uint32_t, POINTER(None))# /usr/local/src/c-toxcore/toxav/toxav.h: 748
|
|
|
|
toxav_audio_data_cb = CFUNCTYPE(UNCHECKED(None), POINTER(None), uint32_t, uint32_t, POINTER(c_int16), uint32_t, uint8_t, uint32_t, POINTER(None))# /usr/local/src/c-toxcore/toxav/toxav.h: 751
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 761
|
|
if _libs["libtoxcore"].has("toxav_add_av_groupchat", "cdecl"):
|
|
toxav_add_av_groupchat = _libs["libtoxcore"].get("toxav_add_av_groupchat", "cdecl")
|
|
toxav_add_av_groupchat.argtypes = [POINTER(Tox), POINTER(toxav_audio_data_cb), POINTER(None)]
|
|
toxav_add_av_groupchat.restype = c_int32
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 770
|
|
if _libs["libtoxcore"].has("toxav_join_av_groupchat", "cdecl"):
|
|
toxav_join_av_groupchat = _libs["libtoxcore"].get("toxav_join_av_groupchat", "cdecl")
|
|
toxav_join_av_groupchat.argtypes = [POINTER(Tox), uint32_t, POINTER(uint8_t), uint16_t, POINTER(toxav_audio_data_cb), POINTER(None)]
|
|
toxav_join_av_groupchat.restype = c_int32
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 788
|
|
if _libs["libtoxcore"].has("toxav_group_send_audio", "cdecl"):
|
|
toxav_group_send_audio = _libs["libtoxcore"].get("toxav_group_send_audio", "cdecl")
|
|
toxav_group_send_audio.argtypes = [POINTER(Tox), uint32_t, POINTER(c_int16), uint32_t, uint8_t, uint32_t]
|
|
toxav_group_send_audio.restype = c_int32
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 807
|
|
if _libs["libtoxcore"].has("toxav_groupchat_enable_av", "cdecl"):
|
|
toxav_groupchat_enable_av = _libs["libtoxcore"].get("toxav_groupchat_enable_av", "cdecl")
|
|
toxav_groupchat_enable_av.argtypes = [POINTER(Tox), uint32_t, POINTER(toxav_audio_data_cb), POINTER(None)]
|
|
toxav_groupchat_enable_av.restype = c_int32
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 816
|
|
if _libs["libtoxcore"].has("toxav_groupchat_disable_av", "cdecl"):
|
|
toxav_groupchat_disable_av = _libs["libtoxcore"].get("toxav_groupchat_disable_av", "cdecl")
|
|
toxav_groupchat_disable_av.argtypes = [POINTER(Tox), uint32_t]
|
|
toxav_groupchat_disable_av.restype = c_int32
|
|
|
|
# /usr/local/src/c-toxcore/toxav/toxav.h: 819
|
|
if _libs["libtoxcore"].has("toxav_groupchat_av_enabled", "cdecl"):
|
|
toxav_groupchat_av_enabled = _libs["libtoxcore"].get("toxav_groupchat_av_enabled", "cdecl")
|
|
toxav_groupchat_av_enabled.argtypes = [POINTER(Tox), uint32_t]
|
|
toxav_groupchat_av_enabled.restype = c_bool
|
|
|
|
Toxav = ToxAV# /usr/local/src/c-toxcore/toxav/toxav.h: 832
|
|
|
|
TOXAV_ERR_CALL = Toxav_Err_Call# /usr/local/src/c-toxcore/toxav/toxav.h: 833
|
|
|
|
TOXAV_ERR_NEW = Toxav_Err_New# /usr/local/src/c-toxcore/toxav/toxav.h: 834
|
|
|
|
TOXAV_ERR_ANSWER = Toxav_Err_Answer# /usr/local/src/c-toxcore/toxav/toxav.h: 835
|
|
|
|
TOXAV_ERR_CALL_CONTROL = Toxav_Err_Call_Control# /usr/local/src/c-toxcore/toxav/toxav.h: 836
|
|
|
|
TOXAV_ERR_BIT_RATE_SET = Toxav_Err_Bit_Rate_Set# /usr/local/src/c-toxcore/toxav/toxav.h: 837
|
|
|
|
TOXAV_ERR_SEND_FRAME = Toxav_Err_Send_Frame# /usr/local/src/c-toxcore/toxav/toxav.h: 838
|
|
|
|
TOXAV_CALL_CONTROL = Toxav_Call_Control# /usr/local/src/c-toxcore/toxav/toxav.h: 839
|
|
|
|
TOXAV_FRIEND_CALL_STATE = enum_Toxav_Friend_Call_State# /usr/local/src/c-toxcore/toxav/toxav.h: 840
|
|
|
|
# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 53
|
|
if _libs["libtoxcore"].has("tox_pass_salt_length", "cdecl"):
|
|
tox_pass_salt_length = _libs["libtoxcore"].get("tox_pass_salt_length", "cdecl")
|
|
tox_pass_salt_length.argtypes = []
|
|
tox_pass_salt_length.restype = uint32_t
|
|
else: LOG_ERROR("tox_pass_salt_length")
|
|
|
|
# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 60
|
|
if _libs["libtoxcore"].has("tox_pass_key_length", "cdecl"):
|
|
tox_pass_key_length = _libs["libtoxcore"].get("tox_pass_key_length", "cdecl")
|
|
tox_pass_key_length.argtypes = []
|
|
tox_pass_key_length.restype = uint32_t
|
|
else: LOG_ERROR("tox_pass_key_length")
|
|
|
|
# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 69
|
|
if _libs["libtoxcore"].has("tox_pass_encryption_extra_length", "cdecl"):
|
|
tox_pass_encryption_extra_length = _libs["libtoxcore"].get("tox_pass_encryption_extra_length", "cdecl")
|
|
tox_pass_encryption_extra_length.argtypes = []
|
|
tox_pass_encryption_extra_length.restype = uint32_t
|
|
else: LOG_ERROR("tox_pass_encryption_extra_length")
|
|
|
|
enum_Tox_Err_Key_Derivation = c_int# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 89
|
|
|
|
TOX_ERR_KEY_DERIVATION_OK = 0# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 89
|
|
|
|
TOX_ERR_KEY_DERIVATION_NULL = (TOX_ERR_KEY_DERIVATION_OK + 1)# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 89
|
|
|
|
TOX_ERR_KEY_DERIVATION_FAILED = (TOX_ERR_KEY_DERIVATION_NULL + 1)# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 89
|
|
|
|
Tox_Err_Key_Derivation = enum_Tox_Err_Key_Derivation# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 89
|
|
|
|
enum_Tox_Err_Encryption = c_int# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 115
|
|
|
|
TOX_ERR_ENCRYPTION_OK = 0# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 115
|
|
|
|
TOX_ERR_ENCRYPTION_NULL = (TOX_ERR_ENCRYPTION_OK + 1)# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 115
|
|
|
|
TOX_ERR_ENCRYPTION_KEY_DERIVATION_FAILED = (TOX_ERR_ENCRYPTION_NULL + 1)# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 115
|
|
|
|
TOX_ERR_ENCRYPTION_FAILED = (TOX_ERR_ENCRYPTION_KEY_DERIVATION_FAILED + 1)# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 115
|
|
|
|
Tox_Err_Encryption = enum_Tox_Err_Encryption# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 115
|
|
|
|
enum_Tox_Err_Decryption = c_int# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 153
|
|
|
|
TOX_ERR_DECRYPTION_OK = 0# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 153
|
|
|
|
TOX_ERR_DECRYPTION_NULL = (TOX_ERR_DECRYPTION_OK + 1)# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 153
|
|
|
|
TOX_ERR_DECRYPTION_INVALID_LENGTH = (TOX_ERR_DECRYPTION_NULL + 1)# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 153
|
|
|
|
TOX_ERR_DECRYPTION_BAD_FORMAT = (TOX_ERR_DECRYPTION_INVALID_LENGTH + 1)# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 153
|
|
|
|
TOX_ERR_DECRYPTION_KEY_DERIVATION_FAILED = (TOX_ERR_DECRYPTION_BAD_FORMAT + 1)# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 153
|
|
|
|
TOX_ERR_DECRYPTION_FAILED = (TOX_ERR_DECRYPTION_KEY_DERIVATION_FAILED + 1)# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 153
|
|
|
|
Tox_Err_Decryption = enum_Tox_Err_Decryption# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 153
|
|
|
|
# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 180
|
|
if _libs["libtoxcore"].has("tox_pass_encrypt", "cdecl"):
|
|
tox_pass_encrypt = _libs["libtoxcore"].get("tox_pass_encrypt", "cdecl")
|
|
tox_pass_encrypt.argtypes = [POINTER(uint8_t), c_size_t, POINTER(uint8_t), c_size_t, POINTER(uint8_t), POINTER(Tox_Err_Encryption)]
|
|
tox_pass_encrypt.restype = c_bool
|
|
else: LOG_ERROR("tox_pass_encrypt")
|
|
|
|
# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 197
|
|
if _libs["libtoxcore"].has("tox_pass_decrypt", "cdecl"):
|
|
tox_pass_decrypt = _libs["libtoxcore"].get("tox_pass_decrypt", "cdecl")
|
|
tox_pass_decrypt.argtypes = [POINTER(uint8_t), c_size_t, POINTER(uint8_t), c_size_t, POINTER(uint8_t), POINTER(Tox_Err_Decryption)]
|
|
tox_pass_decrypt.restype = c_bool
|
|
else: LOG_ERROR("tox_pass_decrypt")
|
|
|
|
# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 222
|
|
class struct_Tox_Pass_Key(Structure):
|
|
pass
|
|
|
|
Tox_Pass_Key = struct_Tox_Pass_Key# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 222
|
|
|
|
# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 229
|
|
if _libs["libtoxcore"].has("tox_pass_key_free", "cdecl"):
|
|
tox_pass_key_free = _libs["libtoxcore"].get("tox_pass_key_free", "cdecl")
|
|
tox_pass_key_free.argtypes = [POINTER(Tox_Pass_Key)]
|
|
tox_pass_key_free.restype = None
|
|
else: LOG_ERROR("tox_pass_key_free")
|
|
|
|
# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 246
|
|
if _libs["libtoxcore"].has("tox_pass_key_derive", "cdecl"):
|
|
tox_pass_key_derive = _libs["libtoxcore"].get("tox_pass_key_derive", "cdecl")
|
|
tox_pass_key_derive.argtypes = [POINTER(uint8_t), c_size_t, POINTER(Tox_Err_Key_Derivation)]
|
|
tox_pass_key_derive.restype = POINTER(Tox_Pass_Key)
|
|
else: LOG_ERROR("tox_pass_key_derive")
|
|
|
|
# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 259
|
|
if _libs["libtoxcore"].has("tox_pass_key_derive_with_salt", "cdecl"):
|
|
tox_pass_key_derive_with_salt = _libs["libtoxcore"].get("tox_pass_key_derive_with_salt", "cdecl")
|
|
tox_pass_key_derive_with_salt.argtypes = [POINTER(uint8_t), c_size_t, uint8_t * int(32), POINTER(Tox_Err_Key_Derivation)]
|
|
tox_pass_key_derive_with_salt.restype = POINTER(Tox_Pass_Key)
|
|
else: LOG_ERROR("tox_pass_key_derive_with_salt")
|
|
|
|
# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 275
|
|
if _libs["libtoxcore"].has("tox_pass_key_encrypt", "cdecl"):
|
|
tox_pass_key_encrypt = _libs["libtoxcore"].get("tox_pass_key_encrypt", "cdecl")
|
|
tox_pass_key_encrypt.argtypes = [POINTER(Tox_Pass_Key), POINTER(uint8_t), c_size_t, POINTER(uint8_t), POINTER(Tox_Err_Encryption)]
|
|
tox_pass_key_encrypt.restype = c_bool
|
|
else: LOG_ERROR("tox_pass_key_encrypt")
|
|
|
|
# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 288
|
|
if _libs["libtoxcore"].has("tox_pass_key_decrypt", "cdecl"):
|
|
tox_pass_key_decrypt = _libs["libtoxcore"].get("tox_pass_key_decrypt", "cdecl")
|
|
tox_pass_key_decrypt.argtypes = [POINTER(Tox_Pass_Key), POINTER(uint8_t), c_size_t, POINTER(uint8_t), POINTER(Tox_Err_Decryption)]
|
|
tox_pass_key_decrypt.restype = c_bool
|
|
else: LOG_ERROR("tox_pass_key_decrypt")
|
|
|
|
enum_Tox_Err_Get_Salt = c_int# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 309
|
|
|
|
TOX_ERR_GET_SALT_OK = 0# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 309
|
|
|
|
TOX_ERR_GET_SALT_NULL = (TOX_ERR_GET_SALT_OK + 1)# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 309
|
|
|
|
TOX_ERR_GET_SALT_BAD_FORMAT = (TOX_ERR_GET_SALT_NULL + 1)# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 309
|
|
|
|
Tox_Err_Get_Salt = enum_Tox_Err_Get_Salt# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 309
|
|
|
|
# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 330
|
|
if _libs["libtoxcore"].has("tox_get_salt", "cdecl"):
|
|
tox_get_salt = _libs["libtoxcore"].get("tox_get_salt", "cdecl")
|
|
tox_get_salt.argtypes = [uint8_t * int(80), uint8_t * int(32), POINTER(Tox_Err_Get_Salt)]
|
|
tox_get_salt.restype = c_bool
|
|
else: LOG_ERROR("tox_get_salt")
|
|
|
|
# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 348
|
|
if _libs["libtoxcore"].has("tox_is_data_encrypted", "cdecl"):
|
|
tox_is_data_encrypted = _libs["libtoxcore"].get("tox_is_data_encrypted", "cdecl")
|
|
tox_is_data_encrypted.argtypes = [uint8_t * int(80)]
|
|
tox_is_data_encrypted.restype = c_bool
|
|
else: LOG_ERROR("tox_is_data_encrypted")
|
|
|
|
TOX_ERR_KEY_DERIVATION = Tox_Err_Key_Derivation# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 356
|
|
|
|
TOX_ERR_ENCRYPTION = Tox_Err_Encryption# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 357
|
|
|
|
TOX_ERR_DECRYPTION = Tox_Err_Decryption# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 358
|
|
|
|
TOX_ERR_GET_SALT = Tox_Err_Get_Salt# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 359
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 140
|
|
try:
|
|
TOX_VERSION_MAJOR = 0
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 150
|
|
try:
|
|
TOX_VERSION_MINOR = 2
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 160
|
|
try:
|
|
TOX_VERSION_PATCH = 18
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 173
|
|
def TOX_VERSION_IS_API_COMPATIBLE(MAJOR, MINOR, PATCH):
|
|
return ((((TOX_VERSION_MAJOR > 0) and (TOX_VERSION_MAJOR == MAJOR)) and ((TOX_VERSION_MINOR > MINOR) or ((TOX_VERSION_MINOR == MINOR) and (TOX_VERSION_PATCH >= PATCH)))) or (((TOX_VERSION_MAJOR == 0) and (MAJOR == 0)) and ((((TOX_VERSION_MINOR > 0) and (TOX_VERSION_MINOR == MINOR)) and (TOX_VERSION_PATCH >= PATCH)) or (((TOX_VERSION_MINOR == 0) and (MINOR == 0)) and (TOX_VERSION_PATCH == PATCH)))))
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 199
|
|
def TOX_VERSION_IS_ABI_COMPATIBLE():
|
|
return (tox_version_is_compatible (TOX_VERSION_MAJOR, TOX_VERSION_MINOR, TOX_VERSION_PATCH))
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 215
|
|
try:
|
|
TOX_PUBLIC_KEY_SIZE = 32
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 222
|
|
try:
|
|
TOX_SECRET_KEY_SIZE = 32
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 231
|
|
try:
|
|
TOX_CONFERENCE_UID_SIZE = 32
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 238
|
|
try:
|
|
TOX_CONFERENCE_ID_SIZE = 32
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 245
|
|
try:
|
|
TOX_NOSPAM_SIZE = sizeof(uint32_t)
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 259
|
|
try:
|
|
TOX_ADDRESS_SIZE = ((TOX_PUBLIC_KEY_SIZE + TOX_NOSPAM_SIZE) + sizeof(uint16_t))
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 268
|
|
try:
|
|
TOX_MAX_NAME_LENGTH = 128
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 277
|
|
try:
|
|
TOX_MAX_STATUS_MESSAGE_LENGTH = 1007
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 286
|
|
try:
|
|
TOX_MAX_FRIEND_REQUEST_LENGTH = 1016
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 295
|
|
try:
|
|
TOX_MAX_MESSAGE_LENGTH = 1372
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 304
|
|
try:
|
|
TOX_MAX_CUSTOM_PACKET_SIZE = 1373
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 311
|
|
try:
|
|
TOX_HASH_LENGTH = 32
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 318
|
|
try:
|
|
TOX_FILE_ID_LENGTH = 32
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 327
|
|
try:
|
|
TOX_MAX_FILENAME_LENGTH = 255
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 339
|
|
try:
|
|
TOX_MAX_HOSTNAME_LENGTH = 255
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3366
|
|
try:
|
|
TOX_GROUP_MAX_TOPIC_LENGTH = 512
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3373
|
|
try:
|
|
TOX_GROUP_MAX_PART_LENGTH = 128
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3380
|
|
try:
|
|
TOX_GROUP_MAX_MESSAGE_LENGTH = 1372
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3387
|
|
try:
|
|
TOX_GROUP_MAX_CUSTOM_LOSSY_PACKET_LENGTH = 1373
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3394
|
|
try:
|
|
TOX_GROUP_MAX_CUSTOM_LOSSLESS_PACKET_LENGTH = 1373
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3401
|
|
try:
|
|
TOX_GROUP_MAX_GROUP_NAME_LENGTH = 48
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3408
|
|
try:
|
|
TOX_GROUP_MAX_PASSWORD_SIZE = 32
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3415
|
|
try:
|
|
TOX_GROUP_CHAT_ID_SIZE = 32
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxcore/tox.h: 3422
|
|
try:
|
|
TOX_GROUP_PEER_PUBLIC_KEY_SIZE = 32
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 51
|
|
try:
|
|
TOX_PASS_SALT_LENGTH = 32
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 58
|
|
try:
|
|
TOX_PASS_KEY_LENGTH = 32
|
|
except:
|
|
pass
|
|
|
|
# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 67
|
|
try:
|
|
TOX_PASS_ENCRYPTION_EXTRA_LENGTH = 80
|
|
except:
|
|
pass
|
|
|
|
Tox = struct_Tox# /usr/local/src/c-toxcore/toxcore/tox.h: 124
|
|
|
|
Tox_System = struct_Tox_System# /usr/local/src/c-toxcore/toxcore/tox.h: 515
|
|
|
|
Tox_Options = struct_Tox_Options# /usr/local/src/c-toxcore/toxcore/tox.h: 533
|
|
|
|
ToxAV = struct_ToxAV# /usr/local/src/c-toxcore/toxav/toxav.h: 84
|
|
|
|
Tox_Pass_Key = struct_Tox_Pass_Key# /usr/local/src/c-toxcore/toxencryptsave/toxencryptsave.h: 222
|
|
|
|
# No inserted files
|
|
|
|
# No prefix-stripping
|
|
|