kotatogram/cmake_helpers
1
0
Fork 0
Code Issues Activity

Updated cmake sources to TDesktop version 3.3

Browse source
This commit is contained in:
Eric Kotato 2021-12-07 17:53:07 +03:00
commit 8caa6fcbf9
12 changed files with 16 additions and 1485 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
CMakeLists.txt
View file

@ -13,12 +13,6 @@ if (LINUX
AND NOT DESKTOP_APP_DISABLE_WAYLAND_INTEGRATION)
add_subdirectory(linux_wayland_helper)
endif()
if (LINUX AND NOT DESKTOP_APP_USE_PACKAGED)
add_subdirectory(linux_glib_helper)
endif()
if (LINUX AND NOT DESKTOP_APP_USE_PACKAGED)
add_subdirectory(linux_gtk_helper)
endif()
if (DESKTOP_APP_USE_ALLOCATION_TRACER)
add_subdirectory(linux_allocation_tracer)
endif()

4
external/qt/CMakeLists.txt vendored
View file

@ -292,10 +292,6 @@ else()
INTERFACE
desktop-app::linux_xcb_helper
$<TARGET_FILE:desktop-app::linux_xcb_helper>
desktop-app::linux_gtk_helper
$<TARGET_FILE:desktop-app::linux_gtk_helper>
desktop-app::linux_glib_helper
$<TARGET_FILE:desktop-app::linux_glib_helper>
fontconfig
freetype
xcb

4
external/qt/qt6/CMakeLists.txt vendored
View file

@ -267,10 +267,6 @@ else()
INTERFACE
desktop-app::linux_xcb_helper
$<TARGET_FILE:desktop-app::linux_xcb_helper>
desktop-app::linux_gtk_helper
$<TARGET_FILE:desktop-app::linux_gtk_helper>
desktop-app::linux_glib_helper
$<TARGET_FILE:desktop-app::linux_glib_helper>
fontconfig
freetype
xcb

1
external/webrtc/CMakeLists.txt vendored
View file

@ -24,6 +24,7 @@ else()
WEBRTC_USE_BUILTIN_ISAC_FLOAT
WEBRTC_LIBRARY_IMPL
WEBRTC_NON_STATIC_TRACE_EVENT_HANDLERS=1
WEBRTC_HAVE_USRSCTP
ABSL_ALLOCATOR_NOTHROW=1
)

5
init_target.cmake
View file

@ -5,9 +5,6 @@
# https://github.com/desktop-app/legal/blob/master/LEGAL
set(MAXIMUM_CXX_STANDARD cxx_std_20)
if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
set(MAXIMUM_CXX_STANDARD cxx_std_17)
endif()
function(init_target_folder target_name folder_name)
if (NOT "${folder_name}" STREQUAL "")
@ -45,7 +42,7 @@ function(init_target target_name) # init_target(my_target folder_name)
XCODE_ATTRIBUTE_LLVM_LTO $<IF:$<CONFIG:Debug>,NO,YES>
)
endif()
if (DESKTOP_APP_SPECIAL_TARGET AND WIN32)
if (DESKTOP_APP_SPECIAL_TARGET AND WIN32 AND NOT build_win64)
set_target_properties(${target_name} PROPERTIES
INTERPROCEDURAL_OPTIMIZATION_RELEASE True
INTERPROCEDURAL_OPTIMIZATION_RELWITHDEBINFO True

29
linux_glib_helper/CMakeLists.txt
View file

@ -1,29 +0,0 @@
# This file is part of Desktop App Toolkit,
# a set of libraries for developing nice desktop applications.
#
# For license and copyright information please follow this link:
# https://github.com/desktop-app/legal/blob/master/LEGAL
add_library(linux_glib_helper STATIC)
init_target(linux_glib_helper "(external)")
add_library(desktop-app::linux_glib_helper ALIAS linux_glib_helper)
nice_target_sources(linux_glib_helper ${CMAKE_CURRENT_SOURCE_DIR}
PRIVATE
linux_glib_helper.cpp
)
target_link_libraries(linux_glib_helper
PUBLIC
${CMAKE_DL_LIBS}
)
find_package(PkgConfig REQUIRED)
pkg_check_modules(GLIB2 REQUIRED glib-2.0)
pkg_check_modules(GOBJECT REQUIRED gobject-2.0)
target_include_directories(linux_glib_helper SYSTEM
PRIVATE
${GLIB2_INCLUDE_DIRS}
${GOBJECT_INCLUDE_DIRS}
)

413
linux_glib_helper/linux_glib_helper.cpp
View file

@ -1,413 +0,0 @@
// This file is part of Desktop App Toolkit,
// a set of libraries for developing nice desktop applications.
//
// For license and copyright information please follow this link:
// https://github.com/desktop-app/legal/blob/master/LEGAL
//
#include <dlfcn.h>
#include <glib.h>
#include <glib-object.h>
#include <memory>
#include <iostream>
#define LOAD_SYMBOL(handle, func) LoadSymbol(handle, #func, func)
namespace GlibHelper {
namespace {
void (*g_free)(gpointer mem);
void (*g_log_default_handler)(
const gchar* log_domain,
GLogLevelFlags log_level,
const gchar* message,
gpointer unused_data);
guint (*g_log_set_handler)(
const gchar* log_domain,
GLogLevelFlags log_levels,
GLogFunc log_func,
gpointer user_data);
GMainContext* (*g_main_context_default)(void);
gboolean (*g_main_context_iteration)(GMainContext* context, gboolean may_block);
GMainContext* (*g_main_context_new)(void);
// TODO: Remove when Qt 5 support will be dropped
gboolean (*g_main_context_pending)(GMainContext* context);
void (*g_main_context_pop_thread_default)(GMainContext* context);
void (*g_main_context_push_thread_default)(GMainContext* context);
GMainContext* (*g_main_context_ref)(GMainContext* context);
void (*g_main_context_unref)(GMainContext* context);
void (*g_main_context_wakeup)(GMainContext* context);
void (*g_return_if_fail_warning)(
const char* log_domain,
const char* pretty_function,
const char* expression);
void (*g_slist_free)(GSList* list);
void (*g_source_add_poll)(GSource* source, GPollFD* fd);
guint (*g_source_attach)(GSource* source, GMainContext* context);
void (*g_source_destroy)(GSource* source);
GSource* (*g_source_new)(GSourceFuncs* source_funcs, guint struct_size);
void (*g_source_remove_poll)(GSource* source, GPollFD* fd);
void (*g_source_set_can_recurse)(GSource* source, gboolean can_recurse);
void (*g_source_set_name)(GSource* source, const char* name);
void (*g_source_unref)(GSource* source);
int (*g_strcmp0)(const char* str1, const char* str2);
GParamSpec* (*g_object_class_find_property)(
GObjectClass* oclass,
const gchar* property_name);
void (*g_object_get_valist)(
GObject* object,
const gchar* first_property_name,
va_list var_args);
GObject* (*g_object_new_with_properties)(
GType object_type,
guint n_properties,
const char** names,
const GValue* values);
GObject* (*g_object_new_valist)(
GType object_type,
const gchar* first_property_name,
va_list var_args);
void (*g_object_set_valist)(
GObject* object,
const gchar* first_property_name,
va_list var_args);
void (*g_object_unref)(gpointer object);
gulong (*g_signal_connect_data)(
gpointer instance,
const gchar* detailed_signal,
GCallback c_handler,
gpointer data,
GClosureNotify destroy_data,
GConnectFlags connect_flags);
GTypeInstance* (*g_type_check_instance_cast)(
GTypeInstance* instance,
GType iface_type);
gboolean (*g_type_check_instance_is_a)(
GTypeInstance* instance,
GType iface_type);
gboolean (*g_type_check_instance_is_fundamentally_a)(
GTypeInstance* instance,
GType fundamental_type);
void (*g_type_ensure)(GType type);
struct HandleDeleter {
void operator()(void *handle) {
dlclose(handle);
}
};
using Handle = std::unique_ptr<void, HandleDeleter>;
bool LoadLibrary(Handle &handle, const char *name) {
handle = Handle(dlopen(name, RTLD_LAZY | RTLD_NODELETE));
if (handle) {
return true;
}
std::cerr << dlerror() << std::endl;
return false;
}
template <typename Function>
inline bool LoadSymbol(const Handle &handle, const char *name, Function &func) {
func = handle
? reinterpret_cast<Function>(dlsym(handle.get(), name))
: nullptr;
if (const auto error = dlerror()) {
std::cerr << error << std::endl;
}
return (func != nullptr);
}
bool Resolve() {
static const auto loaded = [&] {
auto lib = Handle();
return LoadLibrary(lib, "libglib-2.0.so.0")
&& LOAD_SYMBOL(lib, g_free)
&& LOAD_SYMBOL(lib, g_log_default_handler)
&& LOAD_SYMBOL(lib, g_log_set_handler)
&& LOAD_SYMBOL(lib, g_main_context_default)
&& LOAD_SYMBOL(lib, g_main_context_iteration)
&& LOAD_SYMBOL(lib, g_main_context_new)
&& LOAD_SYMBOL(lib, g_main_context_pending)
&& LOAD_SYMBOL(lib, g_main_context_pop_thread_default)
&& LOAD_SYMBOL(lib, g_main_context_push_thread_default)
&& LOAD_SYMBOL(lib, g_main_context_ref)
&& LOAD_SYMBOL(lib, g_main_context_unref)
&& LOAD_SYMBOL(lib, g_main_context_wakeup)
&& LOAD_SYMBOL(lib, g_return_if_fail_warning)
&& LOAD_SYMBOL(lib, g_slist_free)
&& LOAD_SYMBOL(lib, g_source_add_poll)
&& LOAD_SYMBOL(lib, g_source_attach)
&& LOAD_SYMBOL(lib, g_source_destroy)
&& LOAD_SYMBOL(lib, g_source_new)
&& LOAD_SYMBOL(lib, g_source_remove_poll)
&& LOAD_SYMBOL(lib, g_source_set_can_recurse)
&& LOAD_SYMBOL(lib, g_source_set_name)
&& LOAD_SYMBOL(lib, g_source_unref)
&& LOAD_SYMBOL(lib, g_strcmp0)
&& LoadLibrary(lib, "libgobject-2.0.so.0")
&& LOAD_SYMBOL(lib, g_object_class_find_property)
&& LOAD_SYMBOL(lib, g_object_get_valist)
&& LOAD_SYMBOL(lib, g_object_new_valist)
&& LOAD_SYMBOL(lib, g_object_new_with_properties)
&& LOAD_SYMBOL(lib, g_object_set_valist)
&& LOAD_SYMBOL(lib, g_object_unref)
&& LOAD_SYMBOL(lib, g_signal_connect_data)
&& LOAD_SYMBOL(lib, g_type_check_instance_cast)
&& LOAD_SYMBOL(lib, g_type_check_instance_is_a)
&& LOAD_SYMBOL(lib, g_type_check_instance_is_fundamentally_a)
&& LOAD_SYMBOL(lib, g_type_ensure);
}();
return loaded;
}
} // namespace
} // namespace GlibHelper
void g_free(gpointer mem) {
GlibHelper::Resolve();
GlibHelper::g_free(mem);
}
void g_log_default_handler(
const gchar* log_domain,
GLogLevelFlags log_level,
const gchar* message,
gpointer unused_data) {
GlibHelper::Resolve();
GlibHelper::g_log_default_handler(
log_domain,
log_level,
message,
unused_data);
}
guint g_log_set_handler(
const gchar* log_domain,
GLogLevelFlags log_levels,
GLogFunc log_func,
gpointer user_data) {
GlibHelper::Resolve();
return GlibHelper::g_log_set_handler(
log_domain,
log_levels,
log_func,
user_data);
}
GMainContext* g_main_context_default(void) {
GlibHelper::Resolve();
return GlibHelper::g_main_context_default();
}
gboolean g_main_context_iteration(GMainContext* context, gboolean may_block) {
GlibHelper::Resolve();
return GlibHelper::g_main_context_iteration(context, may_block);
}
GMainContext* g_main_context_new(void) {
GlibHelper::Resolve();
return GlibHelper::g_main_context_new();
}
gboolean g_main_context_pending(GMainContext* context) {
GlibHelper::Resolve();
return GlibHelper::g_main_context_pending(context);
}
void g_main_context_pop_thread_default(GMainContext* context) {
GlibHelper::Resolve();
GlibHelper::g_main_context_pop_thread_default(context);
}
void g_main_context_push_thread_default(GMainContext* context) {
GlibHelper::Resolve();
GlibHelper::g_main_context_push_thread_default(context);
}
GMainContext* g_main_context_ref(GMainContext* context) {
GlibHelper::Resolve();
return GlibHelper::g_main_context_ref(context);
}
void g_main_context_unref(GMainContext* context) {
GlibHelper::Resolve();
GlibHelper::g_main_context_unref(context);
}
void g_main_context_wakeup(GMainContext* context) {
GlibHelper::Resolve();
GlibHelper::g_main_context_wakeup(context);
}
void g_return_if_fail_warning(
const char* log_domain,
const char* pretty_function,
const char* expression) {
GlibHelper::Resolve();
GlibHelper::g_return_if_fail_warning(
log_domain,
pretty_function,
expression);
}
void g_slist_free(GSList* list) {
GlibHelper::Resolve();
GlibHelper::g_slist_free(list);
}
void g_source_add_poll(GSource* source, GPollFD* fd) {
GlibHelper::Resolve();
GlibHelper::g_source_add_poll(source, fd);
}
guint g_source_attach(GSource* source, GMainContext* context) {
GlibHelper::Resolve();
return GlibHelper::g_source_attach(source, context);
}
void g_source_destroy(GSource* source) {
GlibHelper::Resolve();
GlibHelper::g_source_destroy(source);
}
GSource* g_source_new(GSourceFuncs* source_funcs, guint struct_size) {
GlibHelper::Resolve();
return GlibHelper::g_source_new(source_funcs, struct_size);
}
void g_source_remove_poll(GSource* source, GPollFD* fd) {
GlibHelper::Resolve();
GlibHelper::g_source_remove_poll(source, fd);
}
void g_source_set_can_recurse(GSource* source, gboolean can_recurse) {
GlibHelper::Resolve();
GlibHelper::g_source_set_can_recurse(source, can_recurse);
}
void g_source_set_name(GSource* source, const char* name) {
GlibHelper::Resolve();
GlibHelper::g_source_set_name(source, name);
}
void g_source_unref(GSource* source) {
GlibHelper::Resolve();
GlibHelper::g_source_unref(source);
}
int g_strcmp0(const char* str1, const char* str2) {
GlibHelper::Resolve();
return GlibHelper::g_strcmp0(str1, str2);
}
GParamSpec* g_object_class_find_property(
GObjectClass* oclass,
const gchar* property_name) {
GlibHelper::Resolve();
return GlibHelper::g_object_class_find_property(
oclass,
property_name);
}
void g_object_get(
gpointer _object,
const gchar *first_property_name,
...) {
GlibHelper::Resolve();
GObject *object = (GObject*) _object;
va_list var_args;
g_return_if_fail(G_IS_OBJECT(object));
va_start(var_args, first_property_name);
GlibHelper::g_object_get_valist(object, first_property_name, var_args);
va_end(var_args);
}
gpointer g_object_new(
GType object_type,
const gchar *first_property_name,
...) {
GlibHelper::Resolve();
GObject *object;
va_list var_args;
/* short circuit for calls supplying no properties */
if (!first_property_name)
return GlibHelper::g_object_new_with_properties(object_type, 0, NULL, NULL);
va_start(var_args, first_property_name);
object = GlibHelper::g_object_new_valist(object_type, first_property_name, var_args);
va_end(var_args);
return object;
}
void g_object_set(
gpointer _object,
const gchar *first_property_name,
...) {
GlibHelper::Resolve();
GObject *object = (GObject*) _object;
va_list var_args;
g_return_if_fail(G_IS_OBJECT(object));
va_start(var_args, first_property_name);
GlibHelper::g_object_set_valist(object, first_property_name, var_args);
va_end(var_args);
}
void g_object_unref(gpointer object) {
GlibHelper::Resolve();
GlibHelper::g_object_unref(object);
}
gulong g_signal_connect_data(
gpointer instance,
const gchar* detailed_signal,
GCallback c_handler,
gpointer data,
GClosureNotify destroy_data,
GConnectFlags connect_flags) {
GlibHelper::Resolve();
return GlibHelper::g_signal_connect_data(
instance,
detailed_signal,
c_handler,
data,
destroy_data,
connect_flags);
}
GTypeInstance* g_type_check_instance_cast(
GTypeInstance* instance,
GType iface_type) {
GlibHelper::Resolve();
return GlibHelper::g_type_check_instance_cast(instance, iface_type);
}
gboolean g_type_check_instance_is_a(
GTypeInstance* instance,
GType iface_type) {
GlibHelper::Resolve();
return GlibHelper::g_type_check_instance_is_a(instance, iface_type);
}
gboolean g_type_check_instance_is_fundamentally_a(
GTypeInstance* instance,
GType fundamental_type) {
GlibHelper::Resolve();
return GlibHelper::g_type_check_instance_is_fundamentally_a(
instance,
fundamental_type);
}
void g_type_ensure(GType type) {
GlibHelper::Resolve();
GlibHelper::g_type_ensure(type);
}

23
linux_gtk_helper/CMakeLists.txt
View file

@ -1,23 +0,0 @@
# This file is part of Desktop App Toolkit,
# a set of libraries for developing nice desktop applications.
#
# For license and copyright information please follow this link:
# https://github.com/desktop-app/legal/blob/master/LEGAL
add_library(linux_gtk_helper STATIC)
init_target(linux_gtk_helper "(external)")
add_library(desktop-app::linux_gtk_helper ALIAS linux_gtk_helper)
nice_target_sources(linux_gtk_helper ${CMAKE_CURRENT_SOURCE_DIR}
PRIVATE
linux_gtk_helper.cpp
)
target_link_libraries(linux_gtk_helper
PUBLIC
${CMAKE_DL_LIBS}
)
find_package(PkgConfig REQUIRED)
pkg_check_modules(GTK REQUIRED gtk+-3.0)
target_include_directories(linux_gtk_helper SYSTEM PRIVATE ${GTK_INCLUDE_DIRS})

996
linux_gtk_helper/linux_gtk_helper.cpp
View file

@ -1,996 +0,0 @@
// This file is part of Desktop App Toolkit,
// a set of libraries for developing nice desktop applications.
//
// For license and copyright information please follow this link:
// https://github.com/desktop-app/legal/blob/master/LEGAL
//
#include <dlfcn.h>
#include <gdk/gdkx.h>
#include <gtk/gtk.h>
#include <memory>
#include <iostream>
#define LOAD_SYMBOL(handle, func) LoadSymbol(handle, #func, func)
namespace GtkHelper {
namespace {
GdkPixbuf *(*gdk_pixbuf_new_from_file_at_size)(
const char *filename,
int width,
int height,
GError **error);
void (*gdk_window_focus)(GdkWindow *window, guint32 timestamp);
GdkDisplay *(*gdk_window_get_display)(GdkWindow *window);
void (*gdk_window_set_modal_hint)(GdkWindow *window, gboolean modal);
Display *(*gdk_x11_display_get_xdisplay)(GdkDisplay *display);
GType (*gdk_x11_window_get_type)(void);
Window (*gdk_x11_window_get_xid)(GdkWindow *window);
GType (*gtk_accel_label_get_type)(void);
void (*gtk_accel_label_set_accel)(
GtkAccelLabel *accel_label,
guint accelerator_key,
GdkModifierType accelerator_mods);
GtkWidget *(*gtk_bin_get_child)(GtkBin *bin);
GType (*gtk_bin_get_type)(void);
GType (*gtk_button_get_type)(void);
void (*gtk_button_set_label)(GtkButton *button, const gchar *label);
gboolean (*gtk_check_menu_item_get_active)(GtkCheckMenuItem *check_menu_item);
GType (*gtk_check_menu_item_get_type)(void);
GtkWidget* (*gtk_check_menu_item_new)(void);
void (*gtk_check_menu_item_set_active)(
GtkCheckMenuItem *check_menu_item,
gboolean is_active);
const gchar *(*gtk_check_version)(
guint required_major,
guint required_minor,
guint required_micro);
GtkClipboard *(*gtk_clipboard_get)(GdkAtom selection);
void (*gtk_clipboard_store)(GtkClipboard *clipboard);
GtkWidget *(*gtk_color_chooser_dialog_new)(
const gchar *title,
GtkWindow *parent);
GType (*gtk_color_chooser_get_type)(void);
void (*gtk_color_chooser_get_rgba)(
GtkColorChooser *chooser,
GdkRGBA *color);
void (*gtk_color_chooser_set_rgba)(
GtkColorChooser *chooser,
const GdkRGBA *color);
void (*gtk_color_chooser_set_use_alpha)(
GtkColorChooser *chooser,
gboolean use_alpha);
GType (*gtk_container_get_type)(void);
void (*gtk_container_remove)(GtkContainer *container, GtkWidget *widget);
GtkWidget *(*gtk_dialog_add_button)(
GtkDialog *dialog,
const gchar *button_text,
gint response_id);
GType (*gtk_dialog_get_type)(void);
GtkWidget* (*gtk_dialog_get_widget_for_response)(
GtkDialog *dialog,
gint response_id);
gint (*gtk_dialog_run)(GtkDialog *dialog);
void (*gtk_file_chooser_add_filter)(
GtkFileChooser *chooser,
GtkFileFilter *filter);
GType (*gtk_file_chooser_dialog_get_type)(void);
gchar *(*gtk_file_chooser_get_current_folder)(GtkFileChooser *chooser);
gchar *(*gtk_file_chooser_get_filename)(GtkFileChooser *chooser);
GSList *(*gtk_file_chooser_get_filenames)(GtkFileChooser *chooser);
GtkFileFilter *(*gtk_file_chooser_get_filter)(GtkFileChooser *chooser);
char *(*gtk_file_chooser_get_preview_filename)(GtkFileChooser *chooser);
GType (*gtk_file_chooser_get_type)(void);
void (*gtk_file_chooser_remove_filter)(
GtkFileChooser *chooser,
GtkFileFilter *filter);
gboolean (*gtk_file_chooser_select_filename)(
GtkFileChooser *chooser,
const char *filename);
void (*gtk_file_chooser_set_action)(
GtkFileChooser *chooser,
GtkFileChooserAction action);
void (*gtk_file_chooser_set_create_folders)(
GtkFileChooser *chooser,
gboolean create_folders);
gboolean (*gtk_file_chooser_set_current_folder)(
GtkFileChooser *chooser,
const gchar *filename);
void (*gtk_file_chooser_set_current_name)(
GtkFileChooser *chooser,
const gchar *name);
void (*gtk_file_chooser_set_do_overwrite_confirmation)(
GtkFileChooser *chooser,
gboolean do_overwrite_confirmation);
void (*gtk_file_chooser_set_filter)(
GtkFileChooser *chooser,
GtkFileFilter *filter);
void (*gtk_file_chooser_set_local_only)(
GtkFileChooser *chooser,
gboolean local_only);
void (*gtk_file_chooser_set_preview_widget)(
GtkFileChooser *chooser,
GtkWidget *preview_widget);
void (*gtk_file_chooser_set_preview_widget_active)(
GtkFileChooser *chooser,
gboolean active);
void (*gtk_file_chooser_set_select_multiple)(
GtkFileChooser *chooser,
gboolean select_multiple);
void (*gtk_file_filter_add_pattern)(
GtkFileFilter *filter,
const gchar *pattern);
GtkFileFilter *(*gtk_file_filter_new)(void);
void (*gtk_file_filter_set_name)(
GtkFileFilter *filter,
const gchar *name);
GtkWidget* (*gtk_font_chooser_dialog_new)(
const gchar *title,
GtkWindow *parent);
gchar* (*gtk_font_chooser_get_font)(GtkFontChooser *fontchooser);
GType (*gtk_font_chooser_get_type)(void);
void (*gtk_font_chooser_set_font)(
GtkFontChooser *fontchooser,
const gchar *fontname);
guint32 (*gtk_get_current_event_time)(void);
GType (*gtk_image_get_type)(void);
GtkWidget* (*gtk_image_new)(void);
void (*gtk_image_set_from_pixbuf)(GtkImage *image, GdkPixbuf *pixbuf);
void (*gtk_init)(int *argc, char ***argv);
GType (*gtk_menu_get_type)(void);
GType (*gtk_menu_item_get_type)(void);
GtkWidget* (*gtk_menu_item_new)(void);
void (*gtk_menu_item_set_label)(GtkMenuItem *menu_item, const gchar *label);
void (*gtk_menu_item_set_submenu)(GtkMenuItem *menu_item, GtkWidget *submenu);
void (*gtk_menu_item_set_use_underline)(
GtkMenuItem *menu_item,
gboolean setting);
GtkWidget* (*gtk_menu_new)(void);
void (*gtk_menu_popdown)(GtkMenu *menu);
void (*gtk_menu_popup)(
GtkMenu *menu,
GtkWidget *parent_menu_shell,
GtkWidget *parent_menu_item,
GtkMenuPositionFunc func,
gpointer data,
guint button,
guint32 activate_time);
GType (*gtk_menu_shell_get_type)(void);
void (*gtk_menu_shell_insert)(
GtkMenuShell *menu_shell,
GtkWidget *child,
gint position);
void (*gtk_menu_shell_select_item)(
GtkMenuShell *menu_shell,
GtkWidget *menu_item);
GtkWidget* (*gtk_separator_menu_item_new)(void);
GtkSettings* (*gtk_settings_get_default)(void);
void (*gtk_widget_destroy)(GtkWidget *widget);
gint (*gtk_widget_get_scale_factor)(GtkWidget *widget);
GType (*gtk_widget_get_type)(void);
GdkWindow *(*gtk_widget_get_window)(GtkWidget *widget);
void (*gtk_widget_hide)(GtkWidget *widget);
gboolean (*gtk_widget_hide_on_delete)(GtkWidget *widget);
void (*gtk_widget_realize)(GtkWidget *widget);
void (*gtk_widget_set_sensitive)(GtkWidget *widget, gboolean sensitive);
void (*gtk_widget_set_visible)(GtkWidget *widget, gboolean visible);
void (*gtk_widget_show)(GtkWidget *widget);
GType (*gtk_window_get_type)(void);
void (*gtk_window_set_title)(GtkWindow *window, const gchar *title);
void (*gtk_window_set_transient_for)(GtkWindow *window, GtkWindow *parent);
void (*pango_font_description_free)(PangoFontDescription *desc);
PangoFontDescription *(*pango_font_description_from_string)(const char *str);
const char *(*pango_font_description_get_family)(
const PangoFontDescription *desc);
gint (*pango_font_description_get_size)(const PangoFontDescription *desc);
PangoStyle (*pango_font_description_get_style)(
const PangoFontDescription *desc);
PangoWeight (*pango_font_description_get_weight)(
const PangoFontDescription *desc);
PangoFontDescription *(*pango_font_description_new)(void);
void (*pango_font_description_set_family)(
PangoFontDescription *desc,
const char *family);
void (*pango_font_description_set_size)(
PangoFontDescription *desc,
gint size);
void (*pango_font_description_set_style)(
PangoFontDescription *desc,
PangoStyle style);
void (*pango_font_description_set_weight)(
PangoFontDescription *desc,
PangoWeight weight);
char *(*pango_font_description_to_string)(const PangoFontDescription *desc);
GType (*pango_font_face_get_type)(void);
GType (*pango_font_family_get_type)(void);
struct HandleDeleter {
void operator()(void *handle) {
dlclose(handle);
}
};
using Handle = std::unique_ptr<void, HandleDeleter>;
bool LoadLibrary(Handle &handle, const char *name) {
handle = Handle(dlopen(name, RTLD_LAZY | RTLD_NODELETE));
if (handle) {
return true;
}
std::cerr << dlerror() << std::endl;
return false;
}
template <typename Function>
inline bool LoadSymbol(const Handle &handle, const char *name, Function &func) {
func = handle
? reinterpret_cast<Function>(dlsym(handle.get(), name))
: nullptr;
if (const auto error = dlerror()) {
std::cerr << error << std::endl;
}
return (func != nullptr);
}
bool Resolve() {
static const auto loaded = [&] {
auto lib = Handle();
return LoadLibrary(lib, "libgtk-3.so.0")
&& LOAD_SYMBOL(lib, gdk_pixbuf_new_from_file_at_size)
&& LOAD_SYMBOL(lib, gdk_window_focus)
&& LOAD_SYMBOL(lib, gdk_window_get_display)
&& LOAD_SYMBOL(lib, gdk_window_set_modal_hint)
&& LOAD_SYMBOL(lib, gdk_x11_display_get_xdisplay)
&& LOAD_SYMBOL(lib, gdk_x11_window_get_type)
&& LOAD_SYMBOL(lib, gdk_x11_window_get_xid)
&& LOAD_SYMBOL(lib, gtk_accel_label_get_type)
&& LOAD_SYMBOL(lib, gtk_accel_label_set_accel)
&& LOAD_SYMBOL(lib, gtk_bin_get_child)
&& LOAD_SYMBOL(lib, gtk_bin_get_type)
&& LOAD_SYMBOL(lib, gtk_button_get_type)
&& LOAD_SYMBOL(lib, gtk_button_set_label)
&& LOAD_SYMBOL(lib, gtk_check_menu_item_get_active)
&& LOAD_SYMBOL(lib, gtk_check_menu_item_get_type)
&& LOAD_SYMBOL(lib, gtk_check_menu_item_new)
&& LOAD_SYMBOL(lib, gtk_check_menu_item_set_active)
&& LOAD_SYMBOL(lib, gtk_check_version)
&& LOAD_SYMBOL(lib, gtk_clipboard_get)
&& LOAD_SYMBOL(lib, gtk_clipboard_store)
&& LOAD_SYMBOL(lib, gtk_color_chooser_dialog_new)
&& LOAD_SYMBOL(lib, gtk_color_chooser_get_rgba)
&& LOAD_SYMBOL(lib, gtk_color_chooser_get_type)
&& LOAD_SYMBOL(lib, gtk_color_chooser_set_rgba)
&& LOAD_SYMBOL(lib, gtk_color_chooser_set_use_alpha)
&& LOAD_SYMBOL(lib, gtk_container_get_type)
&& LOAD_SYMBOL(lib, gtk_container_remove)
&& LOAD_SYMBOL(lib, gtk_dialog_add_button)
&& LOAD_SYMBOL(lib, gtk_dialog_get_type)
&& LOAD_SYMBOL(lib, gtk_dialog_get_widget_for_response)
&& LOAD_SYMBOL(lib, gtk_dialog_run)
&& LOAD_SYMBOL(lib, gtk_file_chooser_add_filter)
&& LOAD_SYMBOL(lib, gtk_file_chooser_dialog_get_type)
&& LOAD_SYMBOL(lib, gtk_file_chooser_get_current_folder)
&& LOAD_SYMBOL(lib, gtk_file_chooser_get_filename)
&& LOAD_SYMBOL(lib, gtk_file_chooser_get_filenames)
&& LOAD_SYMBOL(lib, gtk_file_chooser_get_filter)
&& LOAD_SYMBOL(lib, gtk_file_chooser_get_preview_filename)
&& LOAD_SYMBOL(lib, gtk_file_chooser_get_type)
&& LOAD_SYMBOL(lib, gtk_file_chooser_remove_filter)
&& LOAD_SYMBOL(lib, gtk_file_chooser_select_filename)
&& LOAD_SYMBOL(lib, gtk_file_chooser_set_action)
&& LOAD_SYMBOL(lib, gtk_file_chooser_set_create_folders)
&& LOAD_SYMBOL(lib, gtk_file_chooser_set_current_folder)
&& LOAD_SYMBOL(lib, gtk_file_chooser_set_current_name)
&& LOAD_SYMBOL(lib, gtk_file_chooser_set_do_overwrite_confirmation)
&& LOAD_SYMBOL(lib, gtk_file_chooser_set_filter)
&& LOAD_SYMBOL(lib, gtk_file_chooser_set_local_only)
&& LOAD_SYMBOL(lib, gtk_file_chooser_set_preview_widget)
&& LOAD_SYMBOL(lib, gtk_file_chooser_set_preview_widget_active)
&& LOAD_SYMBOL(lib, gtk_file_chooser_set_select_multiple)
&& LOAD_SYMBOL(lib, gtk_file_filter_add_pattern)
&& LOAD_SYMBOL(lib, gtk_file_filter_new)
&& LOAD_SYMBOL(lib, gtk_file_filter_set_name)
&& LOAD_SYMBOL(lib, gtk_font_chooser_dialog_new)
&& LOAD_SYMBOL(lib, gtk_font_chooser_get_font)
&& LOAD_SYMBOL(lib, gtk_font_chooser_get_type)
&& LOAD_SYMBOL(lib, gtk_font_chooser_set_font)
&& LOAD_SYMBOL(lib, gtk_get_current_event_time)
&& LOAD_SYMBOL(lib, gtk_image_get_type)
&& LOAD_SYMBOL(lib, gtk_image_new)
&& LOAD_SYMBOL(lib, gtk_image_set_from_pixbuf)
&& LOAD_SYMBOL(lib, gtk_init)
&& LOAD_SYMBOL(lib, gtk_menu_get_type)
&& LOAD_SYMBOL(lib, gtk_menu_item_get_type)
&& LOAD_SYMBOL(lib, gtk_menu_item_new)
&& LOAD_SYMBOL(lib, gtk_menu_item_set_label)
&& LOAD_SYMBOL(lib, gtk_menu_item_set_submenu)
&& LOAD_SYMBOL(lib, gtk_menu_item_set_use_underline)
&& LOAD_SYMBOL(lib, gtk_menu_new)
&& LOAD_SYMBOL(lib, gtk_menu_popdown)
&& LOAD_SYMBOL(lib, gtk_menu_popup)
&& LOAD_SYMBOL(lib, gtk_menu_shell_get_type)
&& LOAD_SYMBOL(lib, gtk_menu_shell_insert)
&& LOAD_SYMBOL(lib, gtk_menu_shell_select_item)
&& LOAD_SYMBOL(lib, gtk_separator_menu_item_new)
&& LOAD_SYMBOL(lib, gtk_settings_get_default)
&& LOAD_SYMBOL(lib, gtk_widget_destroy)
&& LOAD_SYMBOL(lib, gtk_widget_get_scale_factor)
&& LOAD_SYMBOL(lib, gtk_widget_get_type)
&& LOAD_SYMBOL(lib, gtk_widget_get_window)
&& LOAD_SYMBOL(lib, gtk_widget_hide)
&& LOAD_SYMBOL(lib, gtk_widget_hide_on_delete)
&& LOAD_SYMBOL(lib, gtk_widget_realize)
&& LOAD_SYMBOL(lib, gtk_widget_set_sensitive)
&& LOAD_SYMBOL(lib, gtk_widget_set_visible)
&& LOAD_SYMBOL(lib, gtk_widget_show)
&& LOAD_SYMBOL(lib, gtk_window_get_type)
&& LOAD_SYMBOL(lib, gtk_window_set_title)
&& LOAD_SYMBOL(lib, gtk_window_set_transient_for)
&& LOAD_SYMBOL(lib, pango_font_description_free)
&& LOAD_SYMBOL(lib, pango_font_description_from_string)
&& LOAD_SYMBOL(lib, pango_font_description_get_family)
&& LOAD_SYMBOL(lib, pango_font_description_get_size)
&& LOAD_SYMBOL(lib, pango_font_description_get_style)
&& LOAD_SYMBOL(lib, pango_font_description_get_weight)
&& LOAD_SYMBOL(lib, pango_font_description_new)
&& LOAD_SYMBOL(lib, pango_font_description_set_family)
&& LOAD_SYMBOL(lib, pango_font_description_set_size)
&& LOAD_SYMBOL(lib, pango_font_description_set_style)
&& LOAD_SYMBOL(lib, pango_font_description_set_weight)
&& LOAD_SYMBOL(lib, pango_font_description_to_string)
&& LOAD_SYMBOL(lib, pango_font_face_get_type)
&& LOAD_SYMBOL(lib, pango_font_family_get_type);
}();
return loaded;
}
} // namespace
} // namespace GtkHelper
GdkPixbuf *gdk_pixbuf_new_from_file_at_size(
const char *filename,
int width,
int height,
GError **error) {
GtkHelper::Resolve();
return GtkHelper::gdk_pixbuf_new_from_file_at_size(
filename,
width,
height,
error);
}
void gdk_window_focus(GdkWindow *window, guint32 timestamp) {
GtkHelper::Resolve();
return GtkHelper::gdk_window_focus(window, timestamp);
}
GdkDisplay *gdk_window_get_display(GdkWindow *window) {
GtkHelper::Resolve();
return GtkHelper::gdk_window_get_display(window);
}
void gdk_window_set_modal_hint(GdkWindow *window, gboolean modal) {
GtkHelper::Resolve();
GtkHelper::gdk_window_set_modal_hint(window, modal);
}
Display *gdk_x11_display_get_xdisplay(GdkDisplay *display) {
GtkHelper::Resolve();
return GtkHelper::gdk_x11_display_get_xdisplay(display);
}
GType gdk_x11_window_get_type(void) {
GtkHelper::Resolve();
return GtkHelper::gdk_x11_window_get_type();
}
Window gdk_x11_window_get_xid(GdkWindow *window) {
GtkHelper::Resolve();
return GtkHelper::gdk_x11_window_get_xid(window);
}
GType gtk_accel_label_get_type(void) {
GtkHelper::Resolve();
return GtkHelper::gtk_accel_label_get_type();
}
void gtk_accel_label_set_accel(
GtkAccelLabel *accel_label,
guint accelerator_key,
GdkModifierType accelerator_mods) {
GtkHelper::Resolve();
GtkHelper::gtk_accel_label_set_accel(
accel_label,
accelerator_key,
accelerator_mods);
}
GtkWidget *gtk_bin_get_child(GtkBin *bin) {
GtkHelper::Resolve();
return GtkHelper::gtk_bin_get_child(bin);
}
GType gtk_bin_get_type(void) {
GtkHelper::Resolve();
return GtkHelper::gtk_bin_get_type();
}
GType gtk_button_get_type(void) {
GtkHelper::Resolve();
return GtkHelper::gtk_button_get_type();
}
void gtk_button_set_label(GtkButton *button, const gchar *label) {
GtkHelper::Resolve();
GtkHelper::gtk_button_set_label(button, label);
}
gboolean gtk_check_menu_item_get_active(GtkCheckMenuItem *check_menu_item) {
GtkHelper::Resolve();
return GtkHelper::gtk_check_menu_item_get_active(check_menu_item);
}
GType gtk_check_menu_item_get_type(void) {
GtkHelper::Resolve();
return GtkHelper::gtk_check_menu_item_get_type();
}
GtkWidget* gtk_check_menu_item_new(void) {
GtkHelper::Resolve();
return GtkHelper::gtk_check_menu_item_new();
}
void gtk_check_menu_item_set_active(
GtkCheckMenuItem *check_menu_item,
gboolean is_active) {
GtkHelper::Resolve();
return GtkHelper::gtk_check_menu_item_set_active(
check_menu_item,
is_active);
}
const gchar *gtk_check_version(
guint required_major,
guint required_minor,
guint required_micro) {
GtkHelper::Resolve();
return GtkHelper::gtk_check_version(
required_major,
required_minor,
required_micro);
}
GtkClipboard *gtk_clipboard_get(GdkAtom selection) {
GtkHelper::Resolve();
return GtkHelper::gtk_clipboard_get(selection);
}
void gtk_clipboard_store(GtkClipboard *clipboard) {
GtkHelper::Resolve();
GtkHelper::gtk_clipboard_store(clipboard);
}
GtkWidget *gtk_color_chooser_dialog_new(
const gchar *title,
GtkWindow *parent) {
GtkHelper::Resolve();
return GtkHelper::gtk_color_chooser_dialog_new(title, parent);
}
GType gtk_color_chooser_get_type(void) {
GtkHelper::Resolve();
return GtkHelper::gtk_color_chooser_get_type();
}
void gtk_color_chooser_get_rgba(
GtkColorChooser *chooser,
GdkRGBA *color) {
GtkHelper::Resolve();
GtkHelper::gtk_color_chooser_get_rgba(chooser, color);
}
void gtk_color_chooser_set_rgba(
GtkColorChooser *chooser,
const GdkRGBA *color) {
GtkHelper::Resolve();
GtkHelper::gtk_color_chooser_set_rgba(chooser, color);
}
void gtk_color_chooser_set_use_alpha(
GtkColorChooser *chooser,
gboolean use_alpha) {
GtkHelper::Resolve();
GtkHelper::gtk_color_chooser_set_use_alpha(chooser, use_alpha);
}
GType gtk_container_get_type(void) {
GtkHelper::Resolve();
return GtkHelper::gtk_container_get_type();
}
void gtk_container_remove(GtkContainer *container, GtkWidget *widget) {
GtkHelper::Resolve();
GtkHelper::gtk_container_remove(container, widget);
}
GType gtk_dialog_get_type(void) {
GtkHelper::Resolve();
return GtkHelper::gtk_dialog_get_type();
}
GtkWidget* gtk_dialog_get_widget_for_response(
GtkDialog *dialog,
gint response_id) {
GtkHelper::Resolve();
return GtkHelper::gtk_dialog_get_widget_for_response(
dialog,
response_id);
}
gint gtk_dialog_run(GtkDialog *dialog) {
GtkHelper::Resolve();
return GtkHelper::gtk_dialog_run(dialog);
}
void gtk_file_chooser_add_filter(
GtkFileChooser *chooser,
GtkFileFilter *filter) {
GtkHelper::Resolve();
GtkHelper::gtk_file_chooser_add_filter(chooser, filter);
}
GtkWidget *gtk_file_chooser_dialog_new(
const gchar *title,
GtkWindow *parent,
GtkFileChooserAction action,
const gchar *first_button_text,
...) {
GtkHelper::Resolve();
va_list varargs;
va_start(varargs, first_button_text);
const auto result = static_cast<GtkWidget*>(g_object_new(
GtkHelper::gtk_file_chooser_dialog_get_type(),
"title",
title,
"action",
action,
nullptr));
if (parent) {
GtkHelper::gtk_window_set_transient_for(GTK_WINDOW(result), parent);
}
auto button_text = first_button_text;
gint response_id;
while (button_text) {
response_id = va_arg(varargs, gint);
GtkHelper::gtk_dialog_add_button(
GTK_DIALOG(result),
button_text,
response_id);
button_text = va_arg(varargs, const gchar *);
}
va_end(varargs);
return result;
}
gchar *gtk_file_chooser_get_current_folder(GtkFileChooser *chooser) {
GtkHelper::Resolve();
return GtkHelper::gtk_file_chooser_get_current_folder(chooser);
}
gchar *gtk_file_chooser_get_filename(GtkFileChooser *chooser) {
GtkHelper::Resolve();
return GtkHelper::gtk_file_chooser_get_filename(chooser);
}
GSList *gtk_file_chooser_get_filenames(GtkFileChooser *chooser) {
GtkHelper::Resolve();
return GtkHelper::gtk_file_chooser_get_filenames(chooser);
}
GtkFileFilter *gtk_file_chooser_get_filter(GtkFileChooser *chooser) {
GtkHelper::Resolve();
return GtkHelper::gtk_file_chooser_get_filter(chooser);
}
char *gtk_file_chooser_get_preview_filename(GtkFileChooser *chooser) {
GtkHelper::Resolve();
return GtkHelper::gtk_file_chooser_get_preview_filename(chooser);
}
GType gtk_file_chooser_get_type(void) {
GtkHelper::Resolve();
return GtkHelper::gtk_file_chooser_get_type();
}
void gtk_file_chooser_remove_filter(
GtkFileChooser *chooser,
GtkFileFilter *filter) {
GtkHelper::Resolve();
GtkHelper::gtk_file_chooser_remove_filter(chooser, filter);
}
gboolean gtk_file_chooser_select_filename(
GtkFileChooser *chooser,
const char *filename) {
GtkHelper::Resolve();
return GtkHelper::gtk_file_chooser_select_filename(chooser, filename);
}
void gtk_file_chooser_set_action(
GtkFileChooser *chooser,
GtkFileChooserAction action) {
GtkHelper::Resolve();
GtkHelper::gtk_file_chooser_set_action(chooser, action);
}
void gtk_file_chooser_set_create_folders(
GtkFileChooser *chooser,
gboolean create_folders) {
GtkHelper::Resolve();
GtkHelper::gtk_file_chooser_set_create_folders(
chooser,
create_folders);
}
gboolean gtk_file_chooser_set_current_folder(
GtkFileChooser *chooser,
const gchar *filename) {
GtkHelper::Resolve();
return GtkHelper::gtk_file_chooser_set_current_folder(chooser, filename);
}
void gtk_file_chooser_set_current_name(
GtkFileChooser *chooser,
const gchar *name) {
GtkHelper::Resolve();
GtkHelper::gtk_file_chooser_set_current_name(chooser, name);
}
void gtk_file_chooser_set_do_overwrite_confirmation(
GtkFileChooser *chooser,
gboolean do_overwrite_confirmation) {
GtkHelper::Resolve();
GtkHelper::gtk_file_chooser_set_do_overwrite_confirmation(
chooser,
do_overwrite_confirmation);
}
void gtk_file_chooser_set_filter(
GtkFileChooser *chooser,
GtkFileFilter *filter) {
GtkHelper::Resolve();
GtkHelper::gtk_file_chooser_set_filter(chooser, filter);
}
void gtk_file_chooser_set_local_only(
GtkFileChooser *chooser,
gboolean local_only) {
GtkHelper::Resolve();
GtkHelper::gtk_file_chooser_set_local_only(chooser, local_only);
}
void gtk_file_chooser_set_preview_widget(
GtkFileChooser *chooser,
GtkWidget *preview_widget) {
GtkHelper::Resolve();
GtkHelper::gtk_file_chooser_set_preview_widget(chooser, preview_widget);
}
void gtk_file_chooser_set_preview_widget_active(
GtkFileChooser *chooser,
gboolean active) {
GtkHelper::Resolve();
GtkHelper::gtk_file_chooser_set_preview_widget_active(chooser, active);
}
void gtk_file_chooser_set_select_multiple(
GtkFileChooser *chooser,
gboolean select_multiple) {
GtkHelper::Resolve();
GtkHelper::gtk_file_chooser_set_select_multiple(chooser, select_multiple);
}
void gtk_file_filter_add_pattern(
GtkFileFilter *filter,
const gchar *pattern) {
GtkHelper::Resolve();
GtkHelper::gtk_file_filter_add_pattern(filter, pattern);
}
GtkFileFilter *gtk_file_filter_new(void) {
GtkHelper::Resolve();
return GtkHelper::gtk_file_filter_new();
}
void gtk_file_filter_set_name(
GtkFileFilter *filter,
const gchar *name) {
GtkHelper::Resolve();
GtkHelper::gtk_file_filter_set_name(filter, name);
}
GtkWidget* gtk_font_chooser_dialog_new(
const gchar *title,
GtkWindow *parent) {
GtkHelper::Resolve();
return GtkHelper::gtk_font_chooser_dialog_new(title, parent);
}
gchar* gtk_font_chooser_get_font(GtkFontChooser *fontchooser) {
GtkHelper::Resolve();
return GtkHelper::gtk_font_chooser_get_font(fontchooser);
}
GType gtk_font_chooser_get_type(void) {
GtkHelper::Resolve();
return GtkHelper::gtk_font_chooser_get_type();
}
void gtk_font_chooser_set_font(
GtkFontChooser *fontchooser,
const gchar *fontname) {
GtkHelper::Resolve();
GtkHelper::gtk_font_chooser_set_font(fontchooser, fontname);
}
guint32 gtk_get_current_event_time(void) {
GtkHelper::Resolve();
return GtkHelper::gtk_get_current_event_time();
}
GType gtk_image_get_type(void) {
GtkHelper::Resolve();
return GtkHelper::gtk_image_get_type();
}
GtkWidget* gtk_image_new(void) {
GtkHelper::Resolve();
return GtkHelper::gtk_image_new();
}
void gtk_image_set_from_pixbuf(GtkImage *image, GdkPixbuf *pixbuf) {
GtkHelper::Resolve();
GtkHelper::gtk_image_set_from_pixbuf(image, pixbuf);
}
void gtk_init(int *argc, char ***argv) {
GtkHelper::Resolve();
GtkHelper::gtk_init(argc, argv);
}
GType gtk_menu_get_type(void) {
GtkHelper::Resolve();
return GtkHelper::gtk_menu_get_type();
}
GType gtk_menu_item_get_type(void) {
GtkHelper::Resolve();
return GtkHelper::gtk_menu_item_get_type();
}
GtkWidget* gtk_menu_item_new(void) {
GtkHelper::Resolve();
return GtkHelper::gtk_menu_item_new();
}
void gtk_menu_item_set_label(GtkMenuItem *menu_item, const gchar *label) {
GtkHelper::Resolve();
GtkHelper::gtk_menu_item_set_label(menu_item, label);
}
void gtk_menu_item_set_submenu(GtkMenuItem *menu_item, GtkWidget *submenu) {
GtkHelper::Resolve();
GtkHelper::gtk_menu_item_set_submenu(menu_item, submenu);
}
void gtk_menu_item_set_use_underline(
GtkMenuItem *menu_item,
gboolean setting) {
GtkHelper::Resolve();
GtkHelper::gtk_menu_item_set_use_underline(menu_item, setting);
}
GtkWidget* gtk_menu_new(void) {
GtkHelper::Resolve();
return GtkHelper::gtk_menu_new();
}
void gtk_menu_popdown(GtkMenu *menu) {
GtkHelper::Resolve();
GtkHelper::gtk_menu_popdown(menu);
}
void gtk_menu_popup(
GtkMenu *menu,
GtkWidget *parent_menu_shell,
GtkWidget *parent_menu_item,
GtkMenuPositionFunc func,
gpointer data,
guint button,
guint32 activate_time) {
GtkHelper::Resolve();
GtkHelper::gtk_menu_popup(
menu,
parent_menu_shell,
parent_menu_item,
func,
data,
button,
activate_time);
}
GType gtk_menu_shell_get_type(void) {
GtkHelper::Resolve();
return GtkHelper::gtk_menu_shell_get_type();
}
void gtk_menu_shell_insert(
GtkMenuShell *menu_shell,
GtkWidget *child,
gint position) {
GtkHelper::Resolve();
GtkHelper::gtk_menu_shell_insert(menu_shell, child, position);
}
void gtk_menu_shell_select_item(
GtkMenuShell *menu_shell,
GtkWidget *menu_item) {
GtkHelper::Resolve();
GtkHelper::gtk_menu_shell_select_item(menu_shell, menu_item);
}
GtkWidget* gtk_separator_menu_item_new(void) {
GtkHelper::Resolve();
return GtkHelper::gtk_separator_menu_item_new();
}
GtkSettings* gtk_settings_get_default(void) {
GtkHelper::Resolve();
return GtkHelper::gtk_settings_get_default();
}
void gtk_widget_destroy(GtkWidget *widget) {
GtkHelper::Resolve();
GtkHelper::gtk_widget_destroy(widget);
}
gint gtk_widget_get_scale_factor(GtkWidget *widget) {
GtkHelper::Resolve();
return GtkHelper::gtk_widget_get_scale_factor(widget);
}
GType gtk_widget_get_type(void) {
GtkHelper::Resolve();
return GtkHelper::gtk_widget_get_type();
}
GdkWindow *gtk_widget_get_window(GtkWidget *widget) {
GtkHelper::Resolve();
return GtkHelper::gtk_widget_get_window(widget);
}
void gtk_widget_hide(GtkWidget *widget) {
GtkHelper::Resolve();
GtkHelper::gtk_widget_hide(widget);
}
gboolean gtk_widget_hide_on_delete(GtkWidget *widget) {
GtkHelper::Resolve();
return GtkHelper::gtk_widget_hide_on_delete(widget);
}
void gtk_widget_realize(GtkWidget *widget) {
GtkHelper::Resolve();
GtkHelper::gtk_widget_realize(widget);
}
void gtk_widget_set_sensitive(GtkWidget *widget, gboolean sensitive) {
GtkHelper::Resolve();
GtkHelper::gtk_widget_set_sensitive(widget, sensitive);
}
void gtk_widget_set_visible(GtkWidget *widget, gboolean visible) {
GtkHelper::Resolve();
GtkHelper::gtk_widget_set_visible(widget, visible);
}
void gtk_widget_show(GtkWidget *widget) {
GtkHelper::Resolve();
GtkHelper::gtk_widget_show(widget);
}
GType gtk_window_get_type(void) {
GtkHelper::Resolve();
return GtkHelper::gtk_window_get_type();
}
void gtk_window_set_title(GtkWindow *window, const gchar *title) {
GtkHelper::Resolve();
GtkHelper::gtk_window_set_title(window, title);
}
void pango_font_description_free(PangoFontDescription *desc) {
GtkHelper::Resolve();
GtkHelper::pango_font_description_free(desc);
}
PangoFontDescription *pango_font_description_from_string(const char *str) {
GtkHelper::Resolve();
return GtkHelper::pango_font_description_from_string(str);
}
const char *pango_font_description_get_family(
const PangoFontDescription *desc) {
GtkHelper::Resolve();
return GtkHelper::pango_font_description_get_family(desc);
}
gint pango_font_description_get_size(const PangoFontDescription *desc) {
GtkHelper::Resolve();
return GtkHelper::pango_font_description_get_size(desc);
}
PangoStyle pango_font_description_get_style(
const PangoFontDescription *desc) {
GtkHelper::Resolve();
return GtkHelper::pango_font_description_get_style(desc);
}
PangoWeight pango_font_description_get_weight(
const PangoFontDescription *desc) {
GtkHelper::Resolve();
return GtkHelper::pango_font_description_get_weight(desc);
}
PangoFontDescription *pango_font_description_new(void) {
GtkHelper::Resolve();
return GtkHelper::pango_font_description_new();
}
void pango_font_description_set_family(
PangoFontDescription *desc,
const char *family) {
GtkHelper::Resolve();
GtkHelper::pango_font_description_set_family(desc, family);
}
void pango_font_description_set_size(
PangoFontDescription *desc,
gint size) {
GtkHelper::Resolve();
GtkHelper::pango_font_description_set_size(desc, size);
}
void pango_font_description_set_style(
PangoFontDescription *desc,
PangoStyle style) {
GtkHelper::Resolve();
GtkHelper::pango_font_description_set_style(desc, style);
}
void pango_font_description_set_weight(
PangoFontDescription *desc,
PangoWeight weight) {
GtkHelper::Resolve();
GtkHelper::pango_font_description_set_weight(desc, weight);
}
char *pango_font_description_to_string(const PangoFontDescription *desc) {
GtkHelper::Resolve();
return GtkHelper::pango_font_description_to_string(desc);
}
GType pango_font_face_get_type(void) {
GtkHelper::Resolve();
return GtkHelper::pango_font_face_get_type();
}
GType pango_font_family_get_type(void) {
GtkHelper::Resolve();
return GtkHelper::pango_font_family_get_type();
}

1
options_linux.cmake
View file

@ -17,6 +17,7 @@ INTERFACE
-Wno-switch
-Wno-missing-field-initializers
-Wno-sign-compare
-Wno-deprecated # implicit capture of 'this' via '[=]' is deprecated in C++20
)
target_compile_definitions(common_options

17
run_cmake.py
View file

@ -12,12 +12,15 @@ def run(project, arguments, buildType=''):
cmake = ['cmake']
windowsArch = ''
explicitGenerator = False
for arg in arguments:
if arg == 'debug':
cmake.append('-DCMAKE_BUILD_TYPE=Debug')
elif arg == 'x86' or arg == 'x64':
windowsArch = arg
elif arg != 'force':
if arg.startswith('-G'):
explicitGenerator = True
cmake.append(arg)
if sys.platform == 'win32':
if windowsArch == 'x64':
@ -29,11 +32,15 @@ def run(project, arguments, buildType=''):
print("[ERROR] x86/x64 switch is supported only on Windows.")
return 1
elif sys.platform == 'darwin':
cmake.append('-GXcode')
elif buildType:
cmake.append('-DCMAKE_BUILD_TYPE=' + buildType)
elif not '-DCMAKE_BUILD_TYPE=Debug' in cmake:
cmake.append('-DCMAKE_BUILD_TYPE=Release')
if not explicitGenerator:
cmake.append('-GXcode')
else:
if not explicitGenerator:
cmake.append('-GNinja Multi-Config')
elif buildType:
cmake.append('-DCMAKE_BUILD_TYPE=' + buildType)
elif not '-DCMAKE_BUILD_TYPE=Debug' in cmake:
cmake.append('-DCMAKE_BUILD_TYPE=Release')
specialTarget = ''
specialTargetFile = scriptPath + '/../' + project + '/build/target'

2
validate_d3d_compiler.py
View file

@ -25,7 +25,7 @@ if not os.path.exists(inputPath):
info = GetFileVersionInfo(inputPath, '\\')
version = [ info['FileVersionMS'] // 65536, info['FileVersionMS'] % 65536, info['FileVersionLS'] // 65536, info['FileVersionLS'] % 65536 ]
if (version != [10, 0, 20348, 1 ]):
if (version != [10, 0, 22000, 194]):
error('Bad "d3dcompiler_47.dll" version: ' + '.'.join(str(x) for x in version))
bufferSize = 1024 * 1024