mirror of https://github.com/bqv/weechat-xmpp
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1640 lines
87 KiB
C++
1640 lines
87 KiB
C++
// This Source Code Form is subject to the terms of the Mozilla Public
|
|
// License, version 2.0. If a copy of the MPL was not distributed with this
|
|
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
#pragma once
|
|
|
|
#include <memory>
|
|
#include <string>
|
|
#include <string_view>
|
|
#include <vector>
|
|
#include <functional>
|
|
#include <optional>
|
|
#include <type_traits>
|
|
#include <cstring>
|
|
#include <stdexcept>
|
|
|
|
#include "weechat.hh"
|
|
#include "config.hh"
|
|
|
|
template<typename Or_Input,
|
|
typename Func,
|
|
typename Input_Type = typename Or_Input::value_type,
|
|
typename Or_Output = std::invoke_result_t<Func, Input_Type>>
|
|
constexpr Or_Output operator>>= (Or_Input input, Func f) {
|
|
static_assert(std::is_invocable_v<decltype(f), Input_Type>,
|
|
"The function passed in must take type "
|
|
"(Or_Input::value_type) as its argument");
|
|
|
|
return input ? std::invoke(f, *input) : std::nullopt;
|
|
}
|
|
|
|
namespace weechat {
|
|
class plugin : public std::reference_wrapper<struct t_weechat_plugin> {
|
|
public:
|
|
plugin();
|
|
explicit plugin(struct t_weechat_plugin* plugin);
|
|
|
|
bool init(std::vector<std::string> args);
|
|
bool end();
|
|
std::string_view name() const;
|
|
weechat::xmpp::config& config();
|
|
|
|
inline operator struct t_weechat_plugin* () const { return &this->get(); }
|
|
inline struct t_weechat_plugin* operator-> () const { return &this->get(); }
|
|
inline plugin& operator= (struct t_weechat_plugin* plugin_ptr) {
|
|
std::reference_wrapper<struct t_weechat_plugin>::operator=(*plugin_ptr);
|
|
return *this;
|
|
}
|
|
|
|
static constexpr const double timer_interval_sec = 0.01;
|
|
|
|
private:
|
|
std::optional<hook> m_process_timer;
|
|
std::optional<gui_bar_item> m_typing_bar_item;
|
|
std::optional<weechat::xmpp::config> m_config;
|
|
};
|
|
|
|
namespace globals {
|
|
extern weechat::plugin plugin;
|
|
}
|
|
|
|
inline const char *plugin_get_name(struct t_weechat_plugin *plugin) {
|
|
return globals::plugin->plugin_get_name(plugin);
|
|
}
|
|
|
|
inline void charset_set(const char *charset) {
|
|
return globals::plugin->charset_set(globals::plugin, charset);
|
|
}
|
|
inline char *iconv_to_internal(const char *charset, const char *string) {
|
|
return globals::plugin->iconv_to_internal(charset, string);
|
|
}
|
|
inline char *iconv_from_internal(const char *charset, const char *string) {
|
|
return globals::plugin->iconv_from_internal(charset, string);
|
|
}
|
|
inline const char *gettext(const char *string) {
|
|
return globals::plugin->gettext(string);
|
|
}
|
|
inline const char *ngettext(const char *single, const char *plural, int count) {
|
|
return globals::plugin->ngettext(single, plural, count);
|
|
}
|
|
inline char *strndup(const char *string, int length) {
|
|
return globals::plugin->strndup(string, length);
|
|
}
|
|
inline void string_tolower(char *string) {
|
|
return globals::plugin->string_tolower(string);
|
|
}
|
|
inline void string_toupper(char *string) {
|
|
return globals::plugin->string_toupper(string);
|
|
}
|
|
inline int strcasecmp(const char *string1, const char *string2) {
|
|
return globals::plugin->strcasecmp(string1, string2);
|
|
}
|
|
inline int strcasecmp_range(const char *string1, const char *string2,
|
|
int range) {
|
|
return globals::plugin->strcasecmp_range(string1, string2, range);
|
|
}
|
|
inline int strncasecmp(const char *string1, const char *string2, int max) {
|
|
return globals::plugin->strncasecmp(string1, string2, max);
|
|
}
|
|
inline int strncasecmp_range(const char *string1, const char *string2,
|
|
int max, int range) {
|
|
return globals::plugin->strncasecmp_range(string1, string2, max, range);
|
|
}
|
|
inline int strcmp_ignore_chars(const char *string1, const char *string2,
|
|
const char *chars_ignored, int case_sensitive) {
|
|
return globals::plugin->strcmp_ignore_chars(string1, string2, chars_ignored, case_sensitive);
|
|
}
|
|
inline const char *strcasestr(const char *string, const char *search) {
|
|
return globals::plugin->strcasestr(string, search);
|
|
}
|
|
inline int strlen_screen(const char *string) {
|
|
return globals::plugin->strlen_screen(string);
|
|
}
|
|
inline int string_match(const char *string, const char *mask,
|
|
int case_sensitive) {
|
|
return globals::plugin->string_match(string, mask, case_sensitive);
|
|
}
|
|
inline int string_match_list(const char *string, const char **masks,
|
|
int case_sensitive) {
|
|
return globals::plugin->string_match_list(string, masks, case_sensitive);
|
|
}
|
|
inline char *string_replace(const char *string, const char *search,
|
|
const char *replace) {
|
|
return globals::plugin->string_replace(string, search, replace);
|
|
}
|
|
inline char *string_expand_home(const char *path) {
|
|
return globals::plugin->string_expand_home(path);
|
|
}
|
|
inline char *string_eval_path_home(const char *path,
|
|
struct t_hashtable *pointers,
|
|
struct t_hashtable *extra_vars,
|
|
struct t_hashtable *options) {
|
|
return globals::plugin->string_eval_path_home(path, pointers, extra_vars, options);
|
|
}
|
|
inline char *string_remove_quotes(const char *string, const char *quotes) {
|
|
return globals::plugin->string_remove_quotes(string, quotes);
|
|
}
|
|
inline char *string_strip(const char *string, int left, int right,
|
|
const char *chars) {
|
|
return globals::plugin->string_strip(string, left, right, chars);
|
|
}
|
|
inline char *string_convert_escaped_chars(const char *string) {
|
|
return globals::plugin->string_convert_escaped_chars(string);
|
|
}
|
|
inline char *string_mask_to_regex(const char *mask) {
|
|
return globals::plugin->string_mask_to_regex(mask);
|
|
}
|
|
inline const char *string_regex_flags(const char *regex, int default_flags,
|
|
int *flags) {
|
|
return globals::plugin->string_regex_flags(regex, default_flags, flags);
|
|
}
|
|
inline int string_regcomp(void *preg, const char *regex, int default_flags) {
|
|
return globals::plugin->string_regcomp(preg, regex, default_flags);
|
|
}
|
|
inline int string_has_highlight(const char *string,
|
|
const char *highlight_words) {
|
|
return globals::plugin->string_has_highlight(string, highlight_words);
|
|
}
|
|
inline int string_has_highlight_regex(const char *string, const char *regex) {
|
|
return globals::plugin->string_has_highlight_regex(string, regex);
|
|
}
|
|
inline char *string_replace_regex(const char *string, void *regex,
|
|
const char *replace,
|
|
const char reference_char,
|
|
char *(*callback)(void *data,
|
|
const char *text),
|
|
void *callback_data) {
|
|
return globals::plugin->string_replace_regex(string, regex, replace, reference_char, callback, callback_data);
|
|
}
|
|
inline char **string_split(const char *string, const char *separators,
|
|
const char *strip_items, int flags,
|
|
int num_items_max, int *num_items) {
|
|
return globals::plugin->string_split(string, separators, strip_items, flags, num_items_max, num_items);
|
|
}
|
|
inline char **string_split_shell(const char *string, int *num_items) {
|
|
return globals::plugin->string_split_shell(string, num_items);
|
|
}
|
|
inline void string_free_split(char **split_string) {
|
|
return globals::plugin->string_free_split(split_string);
|
|
}
|
|
inline char *string_build_with_split_string(const char **split_string,
|
|
const char *separator) {
|
|
return globals::plugin->string_build_with_split_string(split_string, separator);
|
|
}
|
|
inline char **string_split_command(const char *command, char separator) {
|
|
return globals::plugin->string_split_command(command, separator);
|
|
}
|
|
inline void string_free_split_command(char **split_command) {
|
|
return globals::plugin->string_free_split_command(split_command);
|
|
}
|
|
inline char *string_format_size(unsigned long long size) {
|
|
return globals::plugin->string_format_size(size);
|
|
}
|
|
inline int string_color_code_size(const char *string) {
|
|
return globals::plugin->string_color_code_size(string);
|
|
}
|
|
inline char *string_remove_color(const char *string, const char *replacement) {
|
|
return globals::plugin->string_remove_color(string, replacement);
|
|
}
|
|
inline int string_base_encode(int base, const char *from, int length,
|
|
char *to) {
|
|
return globals::plugin->string_base_encode(base, from, length, to);
|
|
}
|
|
inline int string_base_decode(int base, const char *from, char *to) {
|
|
return globals::plugin->string_base_decode(base, from, to);
|
|
}
|
|
inline char *string_hex_dump(const char *data, int data_size,
|
|
int bytes_per_line, const char *prefix,
|
|
const char *suffix) {
|
|
return globals::plugin->string_hex_dump(data, data_size, bytes_per_line, prefix, suffix);
|
|
}
|
|
inline int string_is_command_char(const char *string) {
|
|
return globals::plugin->string_is_command_char(string);
|
|
}
|
|
inline const char *string_input_for_buffer(const char *string) {
|
|
return globals::plugin->string_input_for_buffer(string);
|
|
}
|
|
inline char *string_eval_expression(const char *expr,
|
|
struct t_hashtable *pointers,
|
|
struct t_hashtable *extra_vars,
|
|
struct t_hashtable *options) {
|
|
return globals::plugin->string_eval_expression(expr, pointers, extra_vars, options);
|
|
}
|
|
inline char **string_dyn_alloc(int size_alloc) {
|
|
return globals::plugin->string_dyn_alloc(size_alloc);
|
|
}
|
|
inline int string_dyn_copy(char **string, const char *new_string) {
|
|
return globals::plugin->string_dyn_copy(string, new_string);
|
|
}
|
|
inline int string_dyn_concat(char **string, const char *add, int bytes) {
|
|
return globals::plugin->string_dyn_concat(string, add, bytes);
|
|
}
|
|
inline char *string_dyn_free(char **string, int free_string) {
|
|
return globals::plugin->string_dyn_free(string, free_string);
|
|
}
|
|
|
|
inline int utf8_has_8bits(const char *string) {
|
|
return globals::plugin->utf8_has_8bits(string);
|
|
}
|
|
inline int utf8_is_valid(const char *string, int length, char **error) {
|
|
return globals::plugin->utf8_is_valid(string, length, error);
|
|
}
|
|
inline void utf8_normalize(char *string, char replacement) {
|
|
return globals::plugin->utf8_normalize(string, replacement);
|
|
}
|
|
inline const char *utf8_prev_char(const char *string_start,
|
|
const char *string) {
|
|
return globals::plugin->utf8_prev_char(string_start, string);
|
|
}
|
|
inline const char *utf8_next_char(const char *string) {
|
|
return globals::plugin->utf8_next_char(string);
|
|
}
|
|
inline int utf8_char_int(const char *string) {
|
|
return globals::plugin->utf8_char_int(string);
|
|
}
|
|
inline int utf8_char_size(const char *string) {
|
|
return globals::plugin->utf8_char_size(string);
|
|
}
|
|
inline int utf8_strlen(const char *string) {
|
|
return globals::plugin->utf8_strlen(string);
|
|
}
|
|
inline int utf8_strnlen(const char *string, int bytes) {
|
|
return globals::plugin->utf8_strnlen(string, bytes);
|
|
}
|
|
inline int utf8_strlen_screen(const char *string) {
|
|
return globals::plugin->utf8_strlen_screen(string);
|
|
}
|
|
inline int utf8_charcmp(const char *string1, const char *string2) {
|
|
return globals::plugin->utf8_charcmp(string1, string2);
|
|
}
|
|
inline int utf8_charcasecmp(const char *string1, const char *string2) {
|
|
return globals::plugin->utf8_charcasecmp(string1, string2);
|
|
}
|
|
inline int utf8_char_size_screen(const char *string) {
|
|
return globals::plugin->utf8_char_size_screen(string);
|
|
}
|
|
inline const char *utf8_add_offset(const char *string, int offset) {
|
|
return globals::plugin->utf8_add_offset(string, offset);
|
|
}
|
|
inline int utf8_real_pos(const char *string, int pos) {
|
|
return globals::plugin->utf8_real_pos(string, pos);
|
|
}
|
|
inline int utf8_pos(const char *string, int real_pos) {
|
|
return globals::plugin->utf8_pos(string, real_pos);
|
|
}
|
|
inline char *utf8_strndup(const char *string, int length) {
|
|
return globals::plugin->utf8_strndup(string, length);
|
|
}
|
|
|
|
inline int crypto_hash(const void *data, int data_size,
|
|
const char *hash_algo, void *hash, int *hash_size) {
|
|
return globals::plugin->crypto_hash(data, data_size, hash_algo, hash, hash_size);
|
|
}
|
|
inline int crypto_hash_pbkdf2(const void *data, int data_size,
|
|
const char *hash_algo,
|
|
const void *salt, int salt_size,
|
|
int iterations,
|
|
void *hash, int *hash_size) {
|
|
return globals::plugin->crypto_hash_pbkdf2(data, data_size, hash_algo, salt, salt_size, iterations, hash, hash_size);
|
|
}
|
|
inline int crypto_hmac(const void *key, int key_size,
|
|
const void *message, int message_size,
|
|
const char *hash_algo, void *hash, int *hash_size) {
|
|
return globals::plugin->crypto_hmac(key, key_size, message, message_size, hash_algo, hash, hash_size);
|
|
}
|
|
|
|
inline int mkdir_home(const char *directory, int mode) {
|
|
return globals::plugin->mkdir_home(directory, mode);
|
|
}
|
|
inline int mkdir(const char *directory, int mode) {
|
|
return globals::plugin->mkdir(directory, mode);
|
|
}
|
|
inline int mkdir_parents(const char *directory, int mode) {
|
|
return globals::plugin->mkdir_parents(directory, mode);
|
|
}
|
|
inline void exec_on_files(const char *directory, int recurse_subdirs,
|
|
int hidden_files,
|
|
void (*callback)(void *data, const char *filename),
|
|
void *callback_data) {
|
|
return globals::plugin->exec_on_files(directory, recurse_subdirs, hidden_files, callback, callback_data);
|
|
}
|
|
inline char *file_get_content(const char *filename) {
|
|
return globals::plugin->file_get_content(filename);
|
|
}
|
|
|
|
inline int util_timeval_cmp(struct timeval *tv1, struct timeval *tv2) {
|
|
return globals::plugin->util_timeval_cmp(tv1, tv2);
|
|
}
|
|
inline long long util_timeval_diff(struct timeval *tv1, struct timeval *tv2) {
|
|
return globals::plugin->util_timeval_diff(tv1, tv2);
|
|
}
|
|
inline void util_timeval_add(struct timeval *tv, long long interval) {
|
|
return globals::plugin->util_timeval_add(tv, interval);
|
|
}
|
|
inline const char *util_get_time_string(const time_t *date) {
|
|
return globals::plugin->util_get_time_string(date);
|
|
}
|
|
inline int util_version_number(const char *version) {
|
|
return globals::plugin->util_version_number(version);
|
|
}
|
|
|
|
inline struct t_weelist *list_new() {
|
|
return globals::plugin->list_new();
|
|
}
|
|
inline struct t_weelist_item *list_add(struct t_weelist *weelist,
|
|
const char *data,
|
|
const char *where,
|
|
void *user_data) {
|
|
return globals::plugin->list_add(weelist, data, where, user_data);
|
|
}
|
|
inline struct t_weelist_item *list_search(struct t_weelist *weelist,
|
|
const char *data) {
|
|
return globals::plugin->list_search(weelist, data);
|
|
}
|
|
inline int list_search_pos(struct t_weelist *weelist,
|
|
const char *data) {
|
|
return globals::plugin->list_search_pos(weelist, data);
|
|
}
|
|
inline struct t_weelist_item *list_casesearch(struct t_weelist *weelist,
|
|
const char *data) {
|
|
return globals::plugin->list_casesearch(weelist, data);
|
|
}
|
|
inline int list_casesearch_pos(struct t_weelist *weelist,
|
|
const char *data) {
|
|
return globals::plugin->list_casesearch_pos(weelist, data);
|
|
}
|
|
inline struct t_weelist_item *list_get(struct t_weelist *weelist,
|
|
int position) {
|
|
return globals::plugin->list_get(weelist, position);
|
|
}
|
|
inline void list_set(struct t_weelist_item *item, const char *value) {
|
|
return globals::plugin->list_set(item, value);
|
|
}
|
|
inline struct t_weelist_item *list_next(struct t_weelist_item *item) {
|
|
return globals::plugin->list_next(item);
|
|
}
|
|
inline struct t_weelist_item *list_prev(struct t_weelist_item *item) {
|
|
return globals::plugin->list_prev(item);
|
|
}
|
|
inline const char *list_string(struct t_weelist_item *item) {
|
|
return globals::plugin->list_string(item);
|
|
}
|
|
template<typename T>
|
|
inline T *list_user_data(struct t_weelist_item *item) {
|
|
return static_cast<T*>(
|
|
globals::plugin->list_user_data(item));
|
|
}
|
|
inline int list_size(struct t_weelist *weelist) {
|
|
return globals::plugin->list_size(weelist);
|
|
}
|
|
inline void list_remove(struct t_weelist *weelist,
|
|
struct t_weelist_item *item) {
|
|
return globals::plugin->list_remove(weelist, item);
|
|
}
|
|
inline void list_remove_all(struct t_weelist *weelist) {
|
|
return globals::plugin->list_remove_all(weelist);
|
|
}
|
|
inline void list_free(struct t_weelist *weelist) {
|
|
return globals::plugin->list_free(weelist);
|
|
}
|
|
|
|
inline struct t_arraylist *arraylist_new(int initial_size,
|
|
int sorted,
|
|
int allow_duplicates,
|
|
int (*callback_cmp)(void *data,
|
|
struct t_arraylist *arraylist,
|
|
void *pointer1,
|
|
void *pointer2),
|
|
void *callback_cmp_data,
|
|
void (*callback_free)(void *data,
|
|
struct t_arraylist *arraylist,
|
|
void *pointer),
|
|
void *callback_free_data) {
|
|
return globals::plugin->arraylist_new(initial_size, sorted, allow_duplicates, callback_cmp, callback_cmp_data, callback_free, callback_free_data);
|
|
}
|
|
inline int arraylist_size(struct t_arraylist *arraylist) {
|
|
return globals::plugin->arraylist_size(arraylist);
|
|
}
|
|
template<typename T>
|
|
inline T *arraylist_get(struct t_arraylist *arraylist, int index) {
|
|
return static_cast<T>(
|
|
globals::plugin->arraylist_get(arraylist, index));
|
|
}
|
|
template<typename T>
|
|
inline T *arraylist_search(struct t_arraylist *arraylist, void *pointer,
|
|
int *index, int *index_insert) {
|
|
return static_cast<T>(
|
|
globals::plugin->arraylist_search(arraylist, pointer, index, index_insert));
|
|
}
|
|
inline int arraylist_insert(struct t_arraylist *arraylist, int index,
|
|
void *pointer) {
|
|
return globals::plugin->arraylist_insert(arraylist, index, pointer);
|
|
}
|
|
inline int arraylist_add(struct t_arraylist *arraylist, void *pointer) {
|
|
return globals::plugin->arraylist_add(arraylist, pointer);
|
|
}
|
|
inline int arraylist_remove(struct t_arraylist *arraylist, int index) {
|
|
return globals::plugin->arraylist_remove(arraylist, index);
|
|
}
|
|
inline int arraylist_clear(struct t_arraylist *arraylist) {
|
|
return globals::plugin->arraylist_clear(arraylist);
|
|
}
|
|
inline void arraylist_free(struct t_arraylist *arraylist) {
|
|
return globals::plugin->arraylist_free(arraylist);
|
|
}
|
|
|
|
inline struct t_hashtable *hashtable_new(int size,
|
|
const char *type_keys,
|
|
const char *type_values,
|
|
unsigned long long (*callback_hash_key)(struct t_hashtable *hashtable,
|
|
const void *key),
|
|
int (*callback_keycmp)(struct t_hashtable *hashtable,
|
|
const void *key1,
|
|
const void *key2)) {
|
|
return globals::plugin->hashtable_new(size, type_keys, type_values, callback_hash_key, callback_keycmp);
|
|
}
|
|
inline struct t_hashtable_item *hashtable_set_with_size(struct t_hashtable *hashtable,
|
|
const void *key,
|
|
int key_size,
|
|
const void *value,
|
|
int value_size) {
|
|
return globals::plugin->hashtable_set_with_size(hashtable, key, key_size, value, value_size);
|
|
}
|
|
inline struct t_hashtable_item *hashtable_set(struct t_hashtable *hashtable,
|
|
const void *key,
|
|
const void *value) {
|
|
return globals::plugin->hashtable_set(hashtable, key, value);
|
|
}
|
|
template<typename T>
|
|
inline T *hashtable_get(struct t_hashtable *hashtable, const void *key) {
|
|
return static_cast<T>(
|
|
globals::plugin->hashtable_get(hashtable, key));
|
|
}
|
|
inline int hashtable_has_key(struct t_hashtable *hashtable, const void *key) {
|
|
return globals::plugin->hashtable_has_key(hashtable, key);
|
|
}
|
|
inline void hashtable_map(struct t_hashtable *hashtable,
|
|
void (*callback_map) (void *data,
|
|
struct t_hashtable *hashtable,
|
|
const void *key,
|
|
const void *value),
|
|
void *callback_map_data) {
|
|
return globals::plugin->hashtable_map(hashtable, callback_map, callback_map_data);
|
|
}
|
|
inline void hashtable_map_string(struct t_hashtable *hashtable,
|
|
void (*callback_map) (void *data,
|
|
struct t_hashtable *hashtable,
|
|
const char *key,
|
|
const char *value),
|
|
void *callback_map_data) {
|
|
return globals::plugin->hashtable_map_string(hashtable, callback_map, callback_map_data);
|
|
}
|
|
inline struct t_hashtable *hashtable_dup(struct t_hashtable *hashtable) {
|
|
return globals::plugin->hashtable_dup(hashtable);
|
|
}
|
|
inline int hashtable_get_integer(struct t_hashtable *hashtable,
|
|
const char *property) {
|
|
return globals::plugin->hashtable_get_integer(hashtable, property);
|
|
}
|
|
inline const char *hashtable_get_string(struct t_hashtable *hashtable,
|
|
const char *property) {
|
|
return globals::plugin->hashtable_get_string(hashtable, property);
|
|
}
|
|
inline void hashtable_set_pointer(struct t_hashtable *hashtable,
|
|
const char *property,
|
|
void *pointer) {
|
|
return globals::plugin->hashtable_set_pointer(hashtable, property, pointer);
|
|
}
|
|
inline int hashtable_add_to_infolist(struct t_hashtable *hashtable,
|
|
struct t_infolist_item *infolist_item,
|
|
const char *prefix) {
|
|
return globals::plugin->hashtable_add_to_infolist(hashtable, infolist_item, prefix);
|
|
}
|
|
inline int hashtable_add_from_infolist(struct t_hashtable *hashtable,
|
|
struct t_infolist *infolist,
|
|
const char *prefix) {
|
|
return globals::plugin->hashtable_add_from_infolist(hashtable, infolist, prefix);
|
|
}
|
|
inline void hashtable_remove(struct t_hashtable *hashtable, const void *key) {
|
|
return globals::plugin->hashtable_remove(hashtable, key);
|
|
}
|
|
inline void hashtable_remove_all(struct t_hashtable *hashtable) {
|
|
return globals::plugin->hashtable_remove_all(hashtable);
|
|
}
|
|
inline void hashtable_free(struct t_hashtable *hashtable) {
|
|
return globals::plugin->hashtable_free(hashtable);
|
|
}
|
|
|
|
inline struct t_config_file *config_new(const char *name,
|
|
config_file::reload_callback& reload_cb) {
|
|
return globals::plugin->config_new(
|
|
globals::plugin, name,
|
|
[] (const void *pointer, void *, struct t_config_file *file) {
|
|
<<<<<<< Updated upstream
|
|
auto func = *reinterpret_cast<const config_file::reload_callback*>(pointer);
|
|
=======
|
|
auto& func = *reinterpret_cast<const config_file::reload_callback*>(pointer);
|
|
>>>>>>> Stashed changes
|
|
config_file file_(file);
|
|
return func(file_);
|
|
}, &reload_cb, nullptr);
|
|
}
|
|
inline struct t_config_section *config_new_section(struct t_config_file *file,
|
|
const char *name,
|
|
bool user_can_add_options,
|
|
bool user_can_delete_options,
|
|
<<<<<<< Updated upstream
|
|
config_section::read_callback& read_cb,
|
|
config_section::write_callback& write_cb,
|
|
config_section::write_default_callback& write_default_cb,
|
|
config_section::create_option_callback& create_cb,
|
|
config_section::delete_option_callback& delete_cb) {
|
|
return globals::plugin->config_new_section(
|
|
file, name, user_can_add_options, user_can_delete_options,
|
|
[] (const void *pointer, void *, struct t_config_file *file,
|
|
struct t_config_section *section, const char *key, const char *value) {
|
|
auto func = *reinterpret_cast<const config_section::read_callback*>(pointer);
|
|
config_file file_(file);
|
|
config_section section_(section);
|
|
return func(file_, section_, key, value);
|
|
}, &read_cb, nullptr,
|
|
[] (const void *pointer, void *, struct t_config_file *file, const char *name) {
|
|
auto func = *reinterpret_cast<const config_section::write_callback*>(pointer);
|
|
config_file file_(file);
|
|
return func(file_, name);
|
|
}, &write_cb, nullptr,
|
|
[] (const void *pointer, void *, struct t_config_file *file, const char *name) {
|
|
auto func = *reinterpret_cast<const config_section::write_default_callback*>(pointer);
|
|
config_file file_(file);
|
|
return func(file_, name);
|
|
}, &write_default_cb, nullptr,
|
|
[] (const void *pointer, void *, struct t_config_file *file,
|
|
struct t_config_section *section, const char *key, const char *value) {
|
|
auto func = *reinterpret_cast<const config_section::create_option_callback*>(pointer);
|
|
config_file file_(file);
|
|
config_section section_(section);
|
|
return func(file_, section_, key, value);
|
|
}, &create_cb, nullptr,
|
|
[] (const void *pointer, void *, struct t_config_file *file,
|
|
struct t_config_section *section, struct t_config_option *option) {
|
|
auto func = *reinterpret_cast<const config_section::delete_option_callback*>(pointer);
|
|
=======
|
|
config_section::read_callback *read_cb,
|
|
config_section::write_callback *write_cb,
|
|
config_section::write_default_callback *write_default_cb,
|
|
config_section::create_option_callback *create_cb,
|
|
config_section::delete_option_callback *delete_cb) {
|
|
return globals::plugin->config_new_section(
|
|
file, name, user_can_add_options, user_can_delete_options,
|
|
read_cb ? static_cast<config_section::read_fn>([] (const void *pointer, void *, struct t_config_file *file,
|
|
struct t_config_section *section, const char *key, const char *value) {
|
|
auto& func = *reinterpret_cast<const config_section::read_callback*>(pointer);
|
|
config_file file_(file);
|
|
config_section section_(section);
|
|
return func(file_, section_, key, value);
|
|
}) : nullptr, read_cb, nullptr,
|
|
write_cb ? static_cast<config_section::write_fn>([] (const void *pointer, void *, struct t_config_file *file, const char *name) {
|
|
auto& func = *reinterpret_cast<const config_section::write_callback*>(pointer);
|
|
config_file file_(file);
|
|
return func(file_, name);
|
|
}) : nullptr, write_cb, nullptr,
|
|
write_default_cb ? static_cast<config_section::write_default_fn>([] (const void *pointer, void *, struct t_config_file *file, const char *name) {
|
|
auto& func = *reinterpret_cast<const config_section::write_default_callback*>(pointer);
|
|
config_file file_(file);
|
|
return func(file_, name);
|
|
}) : nullptr, write_default_cb, nullptr,
|
|
create_cb ? static_cast<config_section::create_option_fn>([] (const void *pointer, void *, struct t_config_file *file,
|
|
struct t_config_section *section, const char *key, const char *value) {
|
|
auto& func = *reinterpret_cast<const config_section::create_option_callback*>(pointer);
|
|
config_file file_(file);
|
|
config_section section_(section);
|
|
return func(file_, section_, key, value);
|
|
}) : nullptr, create_cb, nullptr,
|
|
delete_cb ? static_cast<config_section::delete_option_fn>([] (const void *pointer, void *, struct t_config_file *file,
|
|
struct t_config_section *section, struct t_config_option *option) {
|
|
auto& func = *reinterpret_cast<const config_section::delete_option_callback*>(pointer);
|
|
>>>>>>> Stashed changes
|
|
config_file file_(file);
|
|
config_section section_(section);
|
|
config_option option_(option);
|
|
return func(file_, section_, option_);
|
|
<<<<<<< Updated upstream
|
|
}, &delete_cb, nullptr);
|
|
=======
|
|
}) : nullptr, delete_cb, nullptr);
|
|
>>>>>>> Stashed changes
|
|
}
|
|
inline struct t_config_section *config_search_section(struct t_config_file *config_file,
|
|
const char *section_name) {
|
|
return globals::plugin->config_search_section(config_file, section_name);
|
|
}
|
|
inline struct t_config_option *config_new_option(struct t_config_file *config_file,
|
|
struct t_config_section *section,
|
|
const char *name, const char *type,
|
|
const char *description,
|
|
const char *string_values,
|
|
int min, int max,
|
|
const char *default_value,
|
|
const char *value,
|
|
bool null_value_allowed,
|
|
<<<<<<< Updated upstream
|
|
config_option::check_callback& check_value_cb,
|
|
config_option::change_callback& change_cb,
|
|
config_option::delete_callback& delete_cb) {
|
|
=======
|
|
config_option::check_callback *check_value_cb,
|
|
config_option::change_callback *change_cb,
|
|
config_option::delete_callback *delete_cb) {
|
|
>>>>>>> Stashed changes
|
|
return globals::plugin->config_new_option(
|
|
config_file, section,
|
|
name, type, description, string_values,
|
|
min, max, default_value, value, null_value_allowed,
|
|
<<<<<<< Updated upstream
|
|
[] (const void *pointer, void *, struct t_config_option *option, const char *value) {
|
|
auto func = *reinterpret_cast<const config_option::check_callback*>(pointer);
|
|
config_option option_(option);
|
|
return static_cast<int>(func(option_, value));
|
|
}, &check_value_cb, nullptr,
|
|
[] (const void *pointer, void *, struct t_config_option *option) {
|
|
auto func = *reinterpret_cast<const config_option::change_callback*>(pointer);
|
|
config_option option_(option);
|
|
return func(option_);
|
|
}, &change_cb, nullptr,
|
|
[] (const void *pointer, void *, struct t_config_option *option) {
|
|
auto func = *reinterpret_cast<const config_option::delete_callback*>(pointer);
|
|
config_option option_(option);
|
|
return func(option_);
|
|
}, &delete_cb, nullptr);
|
|
=======
|
|
check_value_cb ? static_cast<config_option::check_fn>([] (const void *pointer, void *, struct t_config_option *option, const char *value) {
|
|
auto& func = *reinterpret_cast<const config_option::check_callback*>(pointer);
|
|
config_option option_(option);
|
|
return static_cast<int>(func(option_, value));
|
|
}) : nullptr, check_value_cb, nullptr,
|
|
change_cb ? static_cast<config_option::change_fn>([] (const void *pointer, void *, struct t_config_option *option) {
|
|
auto& func = *reinterpret_cast<const config_option::change_callback*>(pointer);
|
|
config_option option_(option);
|
|
return func(option_);
|
|
}) : nullptr, change_cb, nullptr,
|
|
delete_cb ? static_cast<config_option::delete_fn>([] (const void *pointer, void *, struct t_config_option *option) {
|
|
auto& func = *reinterpret_cast<const config_option::delete_callback*>(pointer);
|
|
config_option option_(option);
|
|
return func(option_);
|
|
}) : nullptr, delete_cb, nullptr);
|
|
>>>>>>> Stashed changes
|
|
}
|
|
inline struct t_config_option *config_search_option(struct t_config_file *config_file,
|
|
struct t_config_section *section,
|
|
const char *option_name) {
|
|
return globals::plugin->config_search_option(config_file, section, option_name);
|
|
}
|
|
inline void config_search_section_option(struct t_config_file *config_file,
|
|
struct t_config_section *section,
|
|
const char *option_name,
|
|
struct t_config_section **section_found,
|
|
struct t_config_option **option_found) {
|
|
return globals::plugin->config_search_section_option(config_file, section, option_name, section_found, option_found);
|
|
}
|
|
inline void config_search_with_string(const char *option_name,
|
|
struct t_config_file **config_file,
|
|
struct t_config_section **section,
|
|
struct t_config_option **option,
|
|
char **pos_option_name) {
|
|
return globals::plugin->config_search_with_string(option_name, config_file, section, option, pos_option_name);
|
|
}
|
|
inline int config_string_to_boolean(const char *text) {
|
|
return globals::plugin->config_string_to_boolean(text);
|
|
}
|
|
inline int config_option_reset(struct t_config_option *option,
|
|
int run_callback) {
|
|
return globals::plugin->config_option_reset(option, run_callback);
|
|
}
|
|
inline int config_option_set(struct t_config_option *option,
|
|
const char *value, int run_callback) {
|
|
return globals::plugin->config_option_set(option, value, run_callback);
|
|
}
|
|
inline int config_option_set_null(struct t_config_option *option,
|
|
int run_callback) {
|
|
return globals::plugin->config_option_set_null(option, run_callback);
|
|
}
|
|
inline int config_option_unset(struct t_config_option *option) {
|
|
return globals::plugin->config_option_unset(option);
|
|
}
|
|
inline void config_option_rename(struct t_config_option *option,
|
|
const char *new_name) {
|
|
return globals::plugin->config_option_rename(option, new_name);
|
|
}
|
|
inline const char *config_option_get_string(struct t_config_option *option,
|
|
const char *property) {
|
|
return globals::plugin->config_option_get_string(option, property);
|
|
}
|
|
template<typename T>
|
|
inline T *config_option_get_pointer(struct t_config_option *option,
|
|
const char *property) {
|
|
return static_cast<T>(
|
|
globals::plugin->config_option_get_pointer(option, property));
|
|
}
|
|
inline int config_option_is_null(struct t_config_option *option) {
|
|
return globals::plugin->config_option_is_null(option);
|
|
}
|
|
inline int config_option_default_is_null(struct t_config_option *option) {
|
|
return globals::plugin->config_option_default_is_null(option);
|
|
}
|
|
inline int config_boolean(struct t_config_option *option) {
|
|
return globals::plugin->config_boolean(option);
|
|
}
|
|
inline int config_boolean_default(struct t_config_option *option) {
|
|
return globals::plugin->config_boolean_default(option);
|
|
}
|
|
inline int config_integer(struct t_config_option *option) {
|
|
return globals::plugin->config_integer(option);
|
|
}
|
|
inline int config_integer_default(struct t_config_option *option) {
|
|
return globals::plugin->config_integer_default(option);
|
|
}
|
|
inline const char *config_string(struct t_config_option *option) {
|
|
return globals::plugin->config_string(option);
|
|
}
|
|
inline const char *config_string_default(struct t_config_option *option) {
|
|
return globals::plugin->config_string_default(option);
|
|
}
|
|
inline const char *config_color(struct t_config_option *option) {
|
|
return globals::plugin->config_color(option);
|
|
}
|
|
inline const char *config_color_default(struct t_config_option *option) {
|
|
return globals::plugin->config_color_default(option);
|
|
}
|
|
inline int config_write_option(struct t_config_file *config_file,
|
|
struct t_config_option *option) {
|
|
return globals::plugin->config_write_option(config_file, option);
|
|
}
|
|
template<typename... Args>
|
|
inline int config_write_line(struct t_config_file *config_file,
|
|
const char *option_name,
|
|
const char *value, Args... args) {
|
|
return globals::plugin->config_write_line(config_file, option_name, value, args...);
|
|
}
|
|
inline int config_write(struct t_config_file *config_file) {
|
|
return globals::plugin->config_write(config_file);
|
|
}
|
|
inline int config_read(struct t_config_file *config_file) {
|
|
return globals::plugin->config_read(config_file);
|
|
}
|
|
inline int config_reload(struct t_config_file *config_file) {
|
|
return globals::plugin->config_reload(config_file);
|
|
}
|
|
inline void config_option_free(struct t_config_option *option) {
|
|
return globals::plugin->config_option_free(option);
|
|
}
|
|
inline void config_section_free_options(struct t_config_section *section) {
|
|
return globals::plugin->config_section_free_options(section);
|
|
}
|
|
inline void config_section_free(struct t_config_section *section) {
|
|
return globals::plugin->config_section_free(section);
|
|
}
|
|
inline void config_free(struct t_config_file *config_file) {
|
|
return globals::plugin->config_free(config_file);
|
|
}
|
|
inline struct t_config_option *config_get(const char *option_name) {
|
|
return globals::plugin->config_get(option_name);
|
|
}
|
|
inline const char *config_get_plugin(const char *option_name) {
|
|
return globals::plugin->config_get_plugin(globals::plugin, option_name);
|
|
}
|
|
inline int config_is_set_plugin(const char *option_name) {
|
|
return globals::plugin->config_is_set_plugin(globals::plugin, option_name);
|
|
}
|
|
inline int config_set_plugin(const char *option_name, const char *value) {
|
|
return globals::plugin->config_set_plugin(globals::plugin, option_name, value);
|
|
}
|
|
inline void config_set_desc_plugin(const char *option_name,
|
|
const char *description) {
|
|
return globals::plugin->config_set_desc_plugin(globals::plugin, option_name, description);
|
|
}
|
|
inline int config_unset_plugin(const char *option_name) {
|
|
return globals::plugin->config_unset_plugin(globals::plugin, option_name);
|
|
}
|
|
|
|
inline int key_bind(const char *context, struct t_hashtable *keys) {
|
|
return globals::plugin->key_bind(context, keys);
|
|
}
|
|
inline int key_unbind(const char *context, const char *key) {
|
|
return globals::plugin->key_unbind(context, key);
|
|
}
|
|
|
|
inline const char *prefix(const char *prefix) {
|
|
return globals::plugin->prefix(prefix);
|
|
}
|
|
inline const char *color(const char *color_name) {
|
|
return globals::plugin->color(color_name);
|
|
}
|
|
template<typename... Args>
|
|
inline void printf(struct t_gui_buffer *buffer, const char *message, Args... args) {
|
|
return globals::plugin->printf_date_tags(
|
|
buffer, 0, nullptr, message, args...);
|
|
}
|
|
template<typename... Args>
|
|
inline void printf_date_tags(struct t_gui_buffer *buffer, time_t date,
|
|
const char *tags, const char *message, Args... args) {
|
|
return globals::plugin->printf_date_tags(buffer, date, tags, message, args...);
|
|
}
|
|
template<typename... Args>
|
|
inline void printf_y(struct t_gui_buffer *buffer, int y,
|
|
const char *message, Args... args) {
|
|
return globals::plugin->printf_y(buffer, y, message, args...);
|
|
}
|
|
template<typename... Args>
|
|
inline void log_printf(const char *message, Args... args) {
|
|
return globals::plugin->log_printf(message, args...);
|
|
}
|
|
|
|
inline struct t_hook *hook_command(const char *command,
|
|
const char *description,
|
|
const char *args,
|
|
const char *args_description,
|
|
const char *completion,
|
|
int (*callback)(const void *pointer,
|
|
void *data,
|
|
struct t_gui_buffer *buffer,
|
|
int argc, char **argv,
|
|
char **argv_eol),
|
|
const void *callback_pointer,
|
|
void *callback_data) {
|
|
return globals::plugin->hook_command(globals::plugin, command, description, args, args_description, completion, callback, callback_pointer, callback_data);
|
|
}
|
|
inline struct t_hook *hook_command_run(const char *command,
|
|
int (*callback)(const void *pointer,
|
|
void *data,
|
|
struct t_gui_buffer *buffer,
|
|
const char *command),
|
|
const void *callback_pointer,
|
|
void *callback_data) {
|
|
return globals::plugin->hook_command_run(globals::plugin, command, callback, callback_pointer, callback_data);
|
|
}
|
|
inline struct t_hook *hook_timer(
|
|
long interval,
|
|
int align_second,
|
|
int max_calls,
|
|
hook::timer_callback *callback) {
|
|
return globals::plugin->hook_timer(
|
|
globals::plugin,
|
|
interval, align_second, max_calls,
|
|
callback ? static_cast<hook::timer_fn>([] (const void *pointer, void *, int remaining_calls) {
|
|
<<<<<<< Updated upstream
|
|
auto func = *reinterpret_cast<const hook::timer_callback*>(pointer);
|
|
=======
|
|
auto& func = *reinterpret_cast<const hook::timer_callback*>(pointer);
|
|
>>>>>>> Stashed changes
|
|
return static_cast<int>(func(remaining_calls));
|
|
}) : nullptr, callback, nullptr);
|
|
}
|
|
inline struct t_hook *hook_fd(int fd,
|
|
int flag_read,
|
|
int flag_write,
|
|
int flag_exception,
|
|
int (*callback)(const void *pointer,
|
|
void *data,
|
|
int fd),
|
|
const void *callback_pointer,
|
|
void *callback_data) {
|
|
return globals::plugin->hook_fd(globals::plugin, fd, flag_read, flag_write, flag_exception, callback, callback_pointer, callback_data);
|
|
}
|
|
inline struct t_hook *hook_process(const char *command,
|
|
int timeout,
|
|
int (*callback)(const void *pointer,
|
|
void *data,
|
|
const char *command,
|
|
int return_code,
|
|
const char *out,
|
|
const char *err),
|
|
const void *callback_pointer,
|
|
void *callback_data) {
|
|
return globals::plugin->hook_process(globals::plugin, command, timeout, callback, callback_pointer, callback_data);
|
|
}
|
|
inline struct t_hook *hook_process_hashtable(const char *command,
|
|
struct t_hashtable *options,
|
|
int timeout,
|
|
int (*callback)(const void *pointer,
|
|
void *data,
|
|
const char *command,
|
|
int return_code,
|
|
const char *out,
|
|
const char *err),
|
|
const void *callback_pointer,
|
|
void *callback_data) {
|
|
return globals::plugin->hook_process_hashtable(globals::plugin, command, options, timeout, callback, callback_pointer, callback_data);
|
|
}
|
|
inline struct t_hook *hook_connect(const char *proxy,
|
|
const char *address,
|
|
int port,
|
|
int ipv6,
|
|
int retry,
|
|
void *gnutls_sess, void *gnutls_cb,
|
|
int gnutls_dhkey_size,
|
|
const char *gnutls_priorities,
|
|
const char *local_hostname,
|
|
int (*callback)(const void *pointer,
|
|
void *data,
|
|
int status,
|
|
int gnutls_rc,
|
|
int sock,
|
|
const char *error,
|
|
const char *ip_address),
|
|
const void *callback_pointer,
|
|
void *callback_data) {
|
|
return globals::plugin->hook_connect(globals::plugin, proxy, address, port, ipv6, retry, gnutls_sess, gnutls_cb, gnutls_dhkey_size, gnutls_priorities, local_hostname, callback, callback_pointer, callback_data);
|
|
}
|
|
inline struct t_hook *hook_line(const char *buffer_type,
|
|
const char *buffer_name,
|
|
const char *tags,
|
|
struct t_hashtable *(*callback)(const void *pointer,
|
|
void *data,
|
|
struct t_hashtable *line),
|
|
const void *callback_pointer,
|
|
void *callback_data) {
|
|
return globals::plugin->hook_line(globals::plugin, buffer_type, buffer_name, tags, callback, callback_pointer, callback_data);
|
|
}
|
|
inline struct t_hook *hook_print(struct t_gui_buffer *buffer,
|
|
const char *tags,
|
|
const char *message,
|
|
int strip_colors,
|
|
int (*callback)(const void *pointer,
|
|
void *data,
|
|
struct t_gui_buffer *buffer,
|
|
time_t date,
|
|
int tags_count,
|
|
const char **tags,
|
|
int displayed,
|
|
int highlight,
|
|
const char *prefix,
|
|
const char *message),
|
|
const void *callback_pointer,
|
|
void *callback_data) {
|
|
return globals::plugin->hook_print(globals::plugin, buffer, tags, message, strip_colors, callback, callback_pointer, callback_data);
|
|
}
|
|
inline struct t_hook *hook_signal(const char *signal,
|
|
int (*callback)(const void *pointer,
|
|
void *data,
|
|
const char *signal,
|
|
const char *type_data,
|
|
void *signal_data),
|
|
const void *callback_pointer = nullptr,
|
|
void *callback_data = nullptr) {
|
|
return globals::plugin->hook_signal(globals::plugin, signal, callback, callback_pointer, callback_data);
|
|
}
|
|
template<typename T>
|
|
inline int hook_signal_send(const char *signal, const char *type_data,
|
|
T signal_data) {
|
|
return globals::plugin->hook_signal_send(signal, type_data, signal_data);
|
|
}
|
|
inline struct t_hook *hook_hsignal(const char *signal,
|
|
int (*callback)(const void *pointer,
|
|
void *data,
|
|
const char *signal,
|
|
struct t_hashtable *hashtable),
|
|
const void *callback_pointer,
|
|
void *callback_data) {
|
|
return globals::plugin->hook_hsignal(globals::plugin, signal, callback, callback_pointer, callback_data);
|
|
}
|
|
inline int hook_hsignal_send(const char *signal,
|
|
struct t_hashtable *hashtable) {
|
|
return globals::plugin->hook_hsignal_send(signal, hashtable);
|
|
}
|
|
inline struct t_hook *hook_config(const char *option,
|
|
int (*callback)(const void *pointer,
|
|
void *data,
|
|
const char *option,
|
|
const char *value),
|
|
const void *callback_pointer,
|
|
void *callback_data) {
|
|
return globals::plugin->hook_config(globals::plugin, option, callback, callback_pointer, callback_data);
|
|
}
|
|
inline struct t_hook *hook_completion(const char *completion_item,
|
|
const char *description,
|
|
int (*callback)(const void *pointer,
|
|
void *data,
|
|
const char *completion_item,
|
|
struct t_gui_buffer *buffer,
|
|
struct t_gui_completion *completion),
|
|
const void *callback_pointer,
|
|
void *callback_data) {
|
|
return globals::plugin->hook_completion(globals::plugin, completion_item, description, callback, callback_pointer, callback_data);
|
|
}
|
|
inline const char *hook_completion_get_string(struct t_gui_completion *completion,
|
|
const char *property) {
|
|
return globals::plugin->hook_completion_get_string(completion, property);
|
|
}
|
|
inline void hook_completion_list_add(struct t_gui_completion *completion,
|
|
const char *word,
|
|
int nick_completion,
|
|
const char *where) {
|
|
return globals::plugin->hook_completion_list_add(completion, word, nick_completion, where);
|
|
}
|
|
inline struct t_hook *hook_modifier(const char *modifier,
|
|
char *(*callback)(const void *pointer,
|
|
void *data,
|
|
const char *modifier,
|
|
const char *modifier_data,
|
|
const char *string),
|
|
const void *callback_pointer,
|
|
void *callback_data) {
|
|
return globals::plugin->hook_modifier(globals::plugin, modifier, callback, callback_pointer, callback_data);
|
|
}
|
|
inline char *hook_modifier_exec(const char *modifier,
|
|
const char *modifier_data,
|
|
const char *string) {
|
|
return globals::plugin->hook_modifier_exec(globals::plugin, modifier, modifier_data, string);
|
|
}
|
|
inline struct t_hook *hook_info(const char *info_name,
|
|
const char *description,
|
|
const char *args_description,
|
|
char *(*callback)(const void *pointer,
|
|
void *data,
|
|
const char *info_name,
|
|
const char *arguments),
|
|
const void *callback_pointer,
|
|
void *callback_data) {
|
|
return globals::plugin->hook_info(globals::plugin, info_name, description, args_description, callback, callback_pointer, callback_data);
|
|
}
|
|
inline struct t_hook *hook_info_hashtable(const char *info_name,
|
|
const char *description,
|
|
const char *args_description,
|
|
const char *output_description,
|
|
struct t_hashtable *(*callback)(const void *pointer,
|
|
void *data,
|
|
const char *info_name,
|
|
struct t_hashtable *hashtable),
|
|
const void *callback_pointer,
|
|
void *callback_data) {
|
|
return globals::plugin->hook_info_hashtable(globals::plugin, info_name, description, args_description, output_description, callback, callback_pointer, callback_data);
|
|
}
|
|
inline struct t_hook *hook_infolist(const char *infolist_name,
|
|
const char *description,
|
|
const char *pointer_description,
|
|
const char *args_description,
|
|
struct t_infolist *(*callback)(const void *cb_pointer,
|
|
void *data,
|
|
const char *infolist_name,
|
|
void *obj_pointer,
|
|
const char *arguments),
|
|
const void *callback_pointer,
|
|
void *callback_data) {
|
|
return globals::plugin->hook_infolist(globals::plugin, infolist_name, description, pointer_description, args_description, callback, callback_pointer, callback_data);
|
|
}
|
|
inline struct t_hook *hook_hdata(const char *hdata_name,
|
|
const char *description,
|
|
struct t_hdata *(*callback)(const void *pointer,
|
|
void *data,
|
|
const char *hdata_name),
|
|
const void *callback_pointer,
|
|
void *callback_data) {
|
|
return globals::plugin->hook_hdata(globals::plugin, hdata_name, description, callback, callback_pointer, callback_data);
|
|
}
|
|
inline struct t_hook *hook_focus(const char *area,
|
|
struct t_hashtable *(*callback)(const void *pointer,
|
|
void *data,
|
|
struct t_hashtable *info),
|
|
const void *callback_pointer,
|
|
void *callback_data) {
|
|
return globals::plugin->hook_focus(globals::plugin, area, callback, callback_pointer, callback_data);
|
|
}
|
|
inline void hook_set(struct t_hook *hook, const char *property,
|
|
const char *value) {
|
|
return globals::plugin->hook_set(hook, property, value);
|
|
}
|
|
inline void unhook(hook& hook) {
|
|
return globals::plugin->unhook(hook);
|
|
}
|
|
inline void unhook_all(const char *plugin) {
|
|
return globals::plugin->unhook_all(globals::plugin, plugin);
|
|
}
|
|
|
|
inline struct t_gui_buffer *buffer_new(const char *name,
|
|
gui_buffer::input_callback& input_cb,
|
|
gui_buffer::close_callback& close_cb) {
|
|
return globals::plugin->buffer_new(
|
|
globals::plugin,
|
|
name,
|
|
[] (const void *pointer, void *,
|
|
struct t_gui_buffer *buffer,
|
|
const char *input_data) {
|
|
<<<<<<< Updated upstream
|
|
auto func = *reinterpret_cast<const gui_buffer::input_callback*>(pointer);
|
|
=======
|
|
auto& func = *reinterpret_cast<const gui_buffer::input_callback*>(pointer);
|
|
>>>>>>> Stashed changes
|
|
gui_buffer buffer_(buffer);
|
|
return static_cast<int>(func(buffer_, input_data));
|
|
}, &input_cb, nullptr,
|
|
[] (const void *pointer, void *,
|
|
struct t_gui_buffer *buffer) {
|
|
<<<<<<< Updated upstream
|
|
auto func = *reinterpret_cast<const gui_buffer::close_callback*>(pointer);
|
|
=======
|
|
auto& func = *reinterpret_cast<const gui_buffer::close_callback*>(pointer);
|
|
>>>>>>> Stashed changes
|
|
gui_buffer buffer_(buffer);
|
|
return static_cast<int>(func(buffer_));
|
|
}, &close_cb, nullptr);
|
|
}
|
|
inline struct t_gui_buffer *buffer_search(const char *plugin, const char *name) {
|
|
return globals::plugin->buffer_search(plugin, name);
|
|
}
|
|
inline struct t_gui_buffer *buffer_search_main() {
|
|
return globals::plugin->buffer_search_main();
|
|
}
|
|
inline void buffer_clear(struct t_gui_buffer *buffer) {
|
|
return globals::plugin->buffer_clear(buffer);
|
|
}
|
|
inline void buffer_close(struct t_gui_buffer *buffer) {
|
|
return globals::plugin->buffer_close(buffer);
|
|
}
|
|
inline void buffer_merge(struct t_gui_buffer *buffer,
|
|
struct t_gui_buffer *target_buffer) {
|
|
return globals::plugin->buffer_merge(buffer, target_buffer);
|
|
}
|
|
inline void buffer_unmerge(struct t_gui_buffer *buffer, int number) {
|
|
return globals::plugin->buffer_unmerge(buffer, number);
|
|
}
|
|
inline int buffer_get_integer(struct t_gui_buffer *buffer,
|
|
const char *property) {
|
|
return globals::plugin->buffer_get_integer(buffer, property);
|
|
}
|
|
inline const char *buffer_get_string(struct t_gui_buffer *buffer,
|
|
const char *property) {
|
|
return globals::plugin->buffer_get_string(buffer, property);
|
|
}
|
|
template<typename T>
|
|
inline T *buffer_get_pointer(struct t_gui_buffer *buffer,
|
|
const char *property) {
|
|
return static_cast<T>(
|
|
globals::plugin->buffer_get_pointer(buffer, property));
|
|
}
|
|
inline void buffer_set(struct t_gui_buffer *buffer, const char *property,
|
|
const char *value) {
|
|
return globals::plugin->buffer_set(buffer, property, value);
|
|
}
|
|
inline void buffer_set_pointer(struct t_gui_buffer *buffer,
|
|
const char *property, void *pointer) {
|
|
return globals::plugin->buffer_set_pointer(buffer, property, pointer);
|
|
}
|
|
inline char *buffer_string_replace_local_var(struct t_gui_buffer *buffer,
|
|
const char *string) {
|
|
return globals::plugin->buffer_string_replace_local_var(buffer, string);
|
|
}
|
|
inline int buffer_match_list(struct t_gui_buffer *buffer, const char *string) {
|
|
return globals::plugin->buffer_match_list(buffer, string);
|
|
}
|
|
|
|
inline struct t_gui_window *window_search_with_buffer(struct t_gui_buffer *buffer) {
|
|
return globals::plugin->window_search_with_buffer(buffer);
|
|
}
|
|
inline int window_get_integer(struct t_gui_window *window,
|
|
const char *property) {
|
|
return globals::plugin->window_get_integer(window, property);
|
|
}
|
|
inline const char *window_get_string(struct t_gui_window *window,
|
|
const char *property) {
|
|
return globals::plugin->window_get_string(window, property);
|
|
}
|
|
template<typename T>
|
|
inline T *window_get_pointer(struct t_gui_window *window,
|
|
const char *property) {
|
|
return static_cast<T>(
|
|
globals::plugin->window_get_pointer(window, property));
|
|
}
|
|
inline struct t_gui_window *current_window() {
|
|
return static_cast<struct t_gui_window *>(
|
|
globals::plugin->window_get_pointer(nullptr, "current"));
|
|
}
|
|
inline void window_set_title(const char *title) {
|
|
return globals::plugin->window_set_title(title);
|
|
}
|
|
|
|
inline struct t_gui_nick_group *nicklist_add_group(struct t_gui_buffer *buffer,
|
|
struct t_gui_nick_group *parent_group,
|
|
const char *name,
|
|
const char *color,
|
|
int visible) {
|
|
return globals::plugin->nicklist_add_group(buffer, parent_group, name, color, visible);
|
|
}
|
|
inline struct t_gui_nick_group *nicklist_search_group(struct t_gui_buffer *buffer,
|
|
struct t_gui_nick_group *from_group,
|
|
const char *name) {
|
|
return globals::plugin->nicklist_search_group(buffer, from_group, name);
|
|
}
|
|
inline struct t_gui_nick *nicklist_add_nick(struct t_gui_buffer *buffer,
|
|
struct t_gui_nick_group *group,
|
|
const char *name,
|
|
const char *color,
|
|
const char *prefix,
|
|
const char *prefix_color,
|
|
int visible) {
|
|
return globals::plugin->nicklist_add_nick(buffer, group, name, color, prefix, prefix_color, visible);
|
|
}
|
|
inline struct t_gui_nick *nicklist_search_nick(struct t_gui_buffer *buffer,
|
|
struct t_gui_nick_group *from_group,
|
|
const char *name) {
|
|
return globals::plugin->nicklist_search_nick(buffer, from_group, name);
|
|
}
|
|
inline void nicklist_remove_group(struct t_gui_buffer *buffer,
|
|
struct t_gui_nick_group *group) {
|
|
return globals::plugin->nicklist_remove_group(buffer, group);
|
|
}
|
|
inline void nicklist_remove_nick(struct t_gui_buffer *buffer,
|
|
struct t_gui_nick *nick) {
|
|
return globals::plugin->nicklist_remove_nick(buffer, nick);
|
|
}
|
|
inline void nicklist_remove_all(struct t_gui_buffer *buffer) {
|
|
return globals::plugin->nicklist_remove_all(buffer);
|
|
}
|
|
inline void nicklist_get_next_item(struct t_gui_buffer *buffer,
|
|
struct t_gui_nick_group **group,
|
|
struct t_gui_nick **nick) {
|
|
return globals::plugin->nicklist_get_next_item(buffer, group, nick);
|
|
}
|
|
inline int nicklist_group_get_integer(struct t_gui_buffer *buffer,
|
|
struct t_gui_nick_group *group,
|
|
const char *property) {
|
|
return globals::plugin->nicklist_group_get_integer(buffer, group, property);
|
|
}
|
|
inline const char *nicklist_group_get_string(struct t_gui_buffer *buffer,
|
|
struct t_gui_nick_group *group,
|
|
const char *property) {
|
|
return globals::plugin->nicklist_group_get_string(buffer, group, property);
|
|
}
|
|
template<typename T>
|
|
inline T *nicklist_group_get_pointer(struct t_gui_buffer *buffer,
|
|
struct t_gui_nick_group *group,
|
|
const char *property) {
|
|
return static_cast<T>(
|
|
globals::plugin->nicklist_group_get_pointer(buffer, group, property));
|
|
}
|
|
inline void nicklist_group_set(struct t_gui_buffer *buffer,
|
|
struct t_gui_nick_group *group,
|
|
const char *property, const char *value) {
|
|
return globals::plugin->nicklist_group_set(buffer, group, property, value);
|
|
}
|
|
inline int nicklist_nick_get_integer(struct t_gui_buffer *buffer,
|
|
struct t_gui_nick *nick,
|
|
const char *property) {
|
|
return globals::plugin->nicklist_nick_get_integer(buffer, nick, property);
|
|
}
|
|
inline const char *nicklist_nick_get_string(struct t_gui_buffer *buffer,
|
|
struct t_gui_nick *nick,
|
|
const char *property) {
|
|
return globals::plugin->nicklist_nick_get_string(buffer, nick, property);
|
|
}
|
|
template<typename T>
|
|
inline T *nicklist_nick_get_pointer(struct t_gui_buffer *buffer,
|
|
struct t_gui_nick *nick,
|
|
const char *property) {
|
|
return static_cast<T>(
|
|
globals::plugin->nicklist_nick_get_pointer(buffer, nick, property));
|
|
}
|
|
inline void nicklist_nick_set(struct t_gui_buffer *buffer,
|
|
struct t_gui_nick *nick,
|
|
const char *property, const char *value) {
|
|
return globals::plugin->nicklist_nick_set(buffer, nick, property, value);
|
|
}
|
|
|
|
inline struct t_gui_bar_item *bar_item_search(const char *name) {
|
|
return globals::plugin->bar_item_search(name);
|
|
}
|
|
inline struct t_gui_bar_item *bar_item_new(
|
|
const char *name,
|
|
gui_bar_item::build_callback& build_callback) {
|
|
return globals::plugin->bar_item_new(
|
|
globals::plugin,
|
|
name, [] (const void *pointer, void *,
|
|
struct t_gui_bar_item *item,
|
|
struct t_gui_window *window,
|
|
struct t_gui_buffer *buffer,
|
|
struct t_hashtable *extra_args) {
|
|
<<<<<<< Updated upstream
|
|
auto func = *reinterpret_cast<const gui_bar_item::build_callback*>(pointer);
|
|
=======
|
|
auto& func = *reinterpret_cast<const gui_bar_item::build_callback*>(pointer);
|
|
>>>>>>> Stashed changes
|
|
gui_bar_item item_(item);
|
|
gui_buffer buffer_(buffer);
|
|
auto res = func(item_, window, buffer_, extra_args);
|
|
char *str = reinterpret_cast<char*>(
|
|
std::calloc(res.size() + 1, sizeof(char)));
|
|
std::copy(res.begin(), res.end(), str);
|
|
str[res.size()] = '\0';
|
|
return str;
|
|
}, &build_callback, nullptr);
|
|
}
|
|
inline void bar_item_update(const char *name) {
|
|
return globals::plugin->bar_item_update(name);
|
|
}
|
|
inline void bar_item_remove(gui_bar_item& item) {
|
|
return globals::plugin->bar_item_remove(item);
|
|
}
|
|
inline struct t_gui_bar *bar_search(const char *name) {
|
|
return globals::plugin->bar_search(name);
|
|
}
|
|
inline struct t_gui_bar *bar_new(const char *name,
|
|
const char *hidden,
|
|
const char *priority,
|
|
const char *type,
|
|
const char *condition,
|
|
const char *position,
|
|
const char *filling_top_bottom,
|
|
const char *filling_left_right,
|
|
const char *size,
|
|
const char *size_max,
|
|
const char *color_fg,
|
|
const char *color_delim,
|
|
const char *color_bg,
|
|
const char *color_bg_inactive,
|
|
const char *separator,
|
|
const char *items) {
|
|
return globals::plugin->bar_new(name, hidden, priority, type, condition, position, filling_top_bottom, filling_left_right, size, size_max, color_fg, color_delim, color_bg, color_bg_inactive, separator, items);
|
|
}
|
|
inline int bar_set(struct t_gui_bar *bar, const char *property,
|
|
const char *value) {
|
|
return globals::plugin->bar_set(bar, property, value);
|
|
}
|
|
inline void bar_update(const char *name) {
|
|
return globals::plugin->bar_update(name);
|
|
}
|
|
inline void bar_remove(struct t_gui_bar *bar) {
|
|
return globals::plugin->bar_remove(bar);
|
|
}
|
|
|
|
inline int command(struct t_gui_buffer *buffer, const char *command) {
|
|
return globals::plugin->command(globals::plugin, buffer, command);
|
|
}
|
|
inline int command_options(struct t_gui_buffer *buffer, const char *command,
|
|
struct t_hashtable *options) {
|
|
return globals::plugin->command_options(globals::plugin, buffer, command, options);
|
|
}
|
|
|
|
inline struct t_gui_completion *completion_new(struct t_gui_buffer *buffer) {
|
|
return globals::plugin->completion_new(globals::plugin, buffer);
|
|
}
|
|
inline int completion_search(struct t_gui_completion *completion,
|
|
const char *data, int position, int direction) {
|
|
return globals::plugin->completion_search(completion, data, position, direction);
|
|
}
|
|
inline const char *completion_get_string(struct t_gui_completion *completion,
|
|
const char *property) {
|
|
return globals::plugin->completion_get_string(completion, property);
|
|
}
|
|
inline void completion_list_add(struct t_gui_completion *completion,
|
|
const char *word,
|
|
int nick_completion,
|
|
const char *where) {
|
|
return globals::plugin->completion_list_add(completion, word, nick_completion, where);
|
|
}
|
|
inline void completion_free(struct t_gui_completion *completion) {
|
|
return globals::plugin->completion_free(completion);
|
|
}
|
|
|
|
inline int network_pass_proxy(const char *proxy, int sock,
|
|
const char *address, int port) {
|
|
return globals::plugin->network_pass_proxy(proxy, sock, address, port);
|
|
}
|
|
inline int network_connect_to(const char *proxy,
|
|
struct sockaddr *address,
|
|
socklen_t address_length) {
|
|
return globals::plugin->network_connect_to(proxy, address, address_length);
|
|
}
|
|
|
|
inline char *info_get(const char *info_name, const char *arguments) {
|
|
return globals::plugin->info_get(globals::plugin, info_name, arguments);
|
|
}
|
|
inline struct t_hashtable *info_get_hashtable(const char *info_name,
|
|
struct t_hashtable *hashtable) {
|
|
return globals::plugin->info_get_hashtable(globals::plugin, info_name, hashtable);
|
|
}
|
|
|
|
inline struct t_infolist *infolist_new() {
|
|
return globals::plugin->infolist_new(globals::plugin);
|
|
}
|
|
inline struct t_infolist_item *infolist_new_item(struct t_infolist *infolist) {
|
|
return globals::plugin->infolist_new_item(infolist);
|
|
}
|
|
inline struct t_infolist_var *infolist_new_var_integer(struct t_infolist_item *item,
|
|
const char *name,
|
|
int value) {
|
|
return globals::plugin->infolist_new_var_integer(item, name, value);
|
|
}
|
|
inline struct t_infolist_var *infolist_new_var_string(struct t_infolist_item *item,
|
|
const char *name,
|
|
const char *value) {
|
|
return globals::plugin->infolist_new_var_string(item, name, value);
|
|
}
|
|
inline struct t_infolist_var *infolist_new_var_pointer(struct t_infolist_item *item,
|
|
const char *name,
|
|
void *pointer) {
|
|
return globals::plugin->infolist_new_var_pointer(item, name, pointer);
|
|
}
|
|
inline struct t_infolist_var *infolist_new_var_buffer(struct t_infolist_item *item,
|
|
const char *name,
|
|
void *pointer,
|
|
int size) {
|
|
return globals::plugin->infolist_new_var_buffer(item, name, pointer, size);
|
|
}
|
|
inline struct t_infolist_var *infolist_new_var_time(struct t_infolist_item *item,
|
|
const char *name,
|
|
time_t time) {
|
|
return globals::plugin->infolist_new_var_time(item, name, time);
|
|
}
|
|
inline struct t_infolist_var *infolist_search_var(struct t_infolist *infolist,
|
|
const char *name) {
|
|
return globals::plugin->infolist_search_var(infolist, name);
|
|
}
|
|
inline struct t_infolist *infolist_get(const char *infolist_name,
|
|
void *pointer,
|
|
const char *arguments) {
|
|
return globals::plugin->infolist_get(globals::plugin, infolist_name, pointer, arguments);
|
|
}
|
|
inline int infolist_next(struct t_infolist *infolist) {
|
|
return globals::plugin->infolist_next(infolist);
|
|
}
|
|
inline int infolist_prev(struct t_infolist *infolist) {
|
|
return globals::plugin->infolist_prev(infolist);
|
|
}
|
|
inline void infolist_reset_item_cursor(struct t_infolist *infolist) {
|
|
return globals::plugin->infolist_reset_item_cursor(infolist);
|
|
}
|
|
inline const char *infolist_fields(struct t_infolist *infolist) {
|
|
return globals::plugin->infolist_fields(infolist);
|
|
}
|
|
inline int infolist_integer(struct t_infolist *infolist, const char *var) {
|
|
return globals::plugin->infolist_integer(infolist, var);
|
|
}
|
|
inline const char *infolist_string(struct t_infolist *infolist, const char *var) {
|
|
return globals::plugin->infolist_string(infolist, var);
|
|
}
|
|
template<typename T>
|
|
inline T *infolist_pointer(struct t_infolist *infolist, const char *var) {
|
|
return static_cast<T>(
|
|
globals::plugin->infolist_pointer(infolist, var));
|
|
}
|
|
template<typename T>
|
|
inline T *infolist_buffer(struct t_infolist *infolist, const char *var,
|
|
int *size) {
|
|
return static_cast<T>(
|
|
globals::plugin->infolist_buffer(infolist, var, size));
|
|
}
|
|
inline time_t infolist_time(struct t_infolist *infolist, const char *var) {
|
|
return globals::plugin->infolist_time(infolist, var);
|
|
}
|
|
inline void infolist_free(struct t_infolist *infolist) {
|
|
return globals::plugin->infolist_free(infolist);
|
|
}
|
|
|
|
inline struct t_hdata *hdata_new(const char *hdata_name, const char *var_prev,
|
|
const char *var_next,
|
|
int create_allowed, int delete_allowed,
|
|
int (*callback_update)(void *data,
|
|
struct t_hdata *hdata,
|
|
void *pointer,
|
|
struct t_hashtable *hashtable),
|
|
void *callback_update_data) {
|
|
return globals::plugin->hdata_new(globals::plugin, hdata_name, var_prev, var_next, create_allowed, delete_allowed, callback_update, callback_update_data);
|
|
}
|
|
inline void hdata_new_var(struct t_hdata *hdata, const char *name, int offset,
|
|
int type, int update_allowed, const char *array_size,
|
|
const char *hdata_name) {
|
|
return globals::plugin->hdata_new_var(hdata, name, offset, type, update_allowed, array_size, hdata_name);
|
|
}
|
|
inline void hdata_new_list(struct t_hdata *hdata, const char *name,
|
|
void *pointer, int flags) {
|
|
return globals::plugin->hdata_new_list(hdata, name, pointer, flags);
|
|
}
|
|
inline struct t_hdata *hdata_get(const char *hdata_name) {
|
|
return globals::plugin->hdata_get(globals::plugin, hdata_name);
|
|
}
|
|
inline int hdata_get_var_offset(struct t_hdata *hdata, const char *name) {
|
|
return globals::plugin->hdata_get_var_offset(hdata, name);
|
|
}
|
|
inline int hdata_get_var_type(struct t_hdata *hdata, const char *name) {
|
|
return globals::plugin->hdata_get_var_type(hdata, name);
|
|
}
|
|
inline const char *hdata_get_var_type_string(struct t_hdata *hdata,
|
|
const char *name) {
|
|
return globals::plugin->hdata_get_var_type_string(hdata, name);
|
|
}
|
|
inline int hdata_get_var_array_size(struct t_hdata *hdata, void *pointer,
|
|
const char *name) {
|
|
return globals::plugin->hdata_get_var_array_size(hdata, pointer, name);
|
|
}
|
|
inline const char *hdata_get_var_array_size_string(struct t_hdata *hdata,
|
|
void *pointer,
|
|
const char *name) {
|
|
return globals::plugin->hdata_get_var_array_size_string(hdata, pointer, name);
|
|
}
|
|
inline const char *hdata_get_var_hdata(struct t_hdata *hdata,
|
|
const char *name) {
|
|
return globals::plugin->hdata_get_var_hdata(hdata, name);
|
|
}
|
|
template<typename T>
|
|
inline T *hdata_get_var(struct t_hdata *hdata, void *pointer,
|
|
const char *name) {
|
|
return static_cast<T>(
|
|
globals::plugin->hdata_get_var(hdata, pointer, name));
|
|
}
|
|
template<typename T>
|
|
inline T *hdata_get_var_at_offset(struct t_hdata *hdata, void *pointer,
|
|
int offset) {
|
|
return static_cast<T>(
|
|
globals::plugin->hdata_get_var_at_offset(hdata, pointer, offset));
|
|
}
|
|
template<typename T>
|
|
inline T *hdata_get_list(struct t_hdata *hdata, const char *name) {
|
|
return static_cast<T>(
|
|
globals::plugin->hdata_get_list(hdata, name));
|
|
}
|
|
inline int hdata_check_pointer(struct t_hdata *hdata, void *list,
|
|
void *pointer) {
|
|
return globals::plugin->hdata_check_pointer(hdata, list, pointer);
|
|
}
|
|
template<typename T>
|
|
inline T *hdata_move(struct t_hdata *hdata, void *pointer, int count) {
|
|
return static_cast<T>(
|
|
globals::plugin->hdata_move(hdata, pointer, count));
|
|
}
|
|
template<typename T>
|
|
inline T *hdata_search(struct t_hdata *hdata, void *pointer,
|
|
const char *search, int move) {
|
|
return static_cast<T>(
|
|
globals::plugin->hdata_search(hdata, pointer, search, move));
|
|
}
|
|
inline char hdata_char(struct t_hdata *hdata, void *pointer,
|
|
const char *name) {
|
|
return globals::plugin->hdata_char(hdata, pointer, name);
|
|
}
|
|
inline int hdata_integer(struct t_hdata *hdata, void *pointer,
|
|
const char *name) {
|
|
return globals::plugin->hdata_integer(hdata, pointer, name);
|
|
}
|
|
inline long hdata_long(struct t_hdata *hdata, void *pointer,
|
|
const char *name) {
|
|
return globals::plugin->hdata_long(hdata, pointer, name);
|
|
}
|
|
inline const char *hdata_string(struct t_hdata *hdata, void *pointer,
|
|
const char *name) {
|
|
return globals::plugin->hdata_string(hdata, pointer, name);
|
|
}
|
|
template<typename T>
|
|
inline T *hdata_pointer(struct t_hdata *hdata, void *pointer,
|
|
const char *name) {
|
|
return static_cast<T>(
|
|
globals::plugin->hdata_pointer(hdata, pointer, name));
|
|
}
|
|
inline time_t hdata_time(struct t_hdata *hdata, void *pointer,
|
|
const char *name) {
|
|
return globals::plugin->hdata_time(hdata, pointer, name);
|
|
}
|
|
inline struct t_hashtable *hdata_hashtable(struct t_hdata *hdata,
|
|
void *pointer, const char *name) {
|
|
return globals::plugin->hdata_hashtable(hdata, pointer, name);
|
|
}
|
|
inline int hdata_compare(struct t_hdata *hdata,
|
|
void *pointer1, void *pointer2, const char *name,
|
|
int case_sensitive) {
|
|
return globals::plugin->hdata_compare(hdata, pointer1, pointer2, name, case_sensitive);
|
|
}
|
|
inline int hdata_set(struct t_hdata *hdata, void *pointer, const char *name,
|
|
const char *value) {
|
|
return globals::plugin->hdata_set(hdata, pointer, name, value);
|
|
}
|
|
inline int hdata_update(struct t_hdata *hdata, void *pointer,
|
|
struct t_hashtable *hashtable) {
|
|
return globals::plugin->hdata_update(hdata, pointer, hashtable);
|
|
}
|
|
inline const char *hdata_get_string(struct t_hdata *hdata,
|
|
const char *property) {
|
|
return globals::plugin->hdata_get_string(hdata, property);
|
|
}
|
|
|
|
inline struct t_upgrade_file *upgrade_new(const char *filename,
|
|
int (*callback_read)(const void *pointer,
|
|
void *data,
|
|
struct t_upgrade_file *upgrade_file,
|
|
int object_id,
|
|
struct t_infolist *infolist),
|
|
const void *callback_read_pointer,
|
|
void *callback_read_data) {
|
|
return globals::plugin->upgrade_new(filename, callback_read, callback_read_pointer, callback_read_data);
|
|
}
|
|
inline int upgrade_write_object(struct t_upgrade_file *upgrade_file,
|
|
int object_id,
|
|
struct t_infolist *infolist) {
|
|
return globals::plugin->upgrade_write_object(upgrade_file, object_id, infolist);
|
|
}
|
|
inline int upgrade_read(struct t_upgrade_file *upgrade_file) {
|
|
return globals::plugin->upgrade_read(upgrade_file);
|
|
}
|
|
inline void upgrade_close(struct t_upgrade_file *upgrade_file) {
|
|
return globals::plugin->upgrade_close(upgrade_file);
|
|
}
|
|
}
|