Subversion Repositories eduke32

Compare Revisions

Ignore whitespace Rev 4771 → Rev 4772

/polymer/eduke32/build/include/dynamicgtk.h
19,385 → 19,367
#define G_GNUC_NULL_TERMINATED
#endif
 
struct _dynamicgtksyms {
 
// glib.h
void (*g_free) (gpointer mem);
// gobject.h
gpointer (*g_object_get_data) (GObject *object,
const gchar *key);
void (*g_object_set_data) (GObject *object,
const gchar *key,
gpointer data);
void (*g_object_set_data_full) (GObject *object,
const gchar *key,
gpointer data,
GDestroyNotify destroy);
void (*g_object_unref) (gpointer object);
// glib.h
typedef void (*g_free_ptr) (gpointer mem);
 
// gsignal.h
gulong (*g_signal_connect_data) (gpointer instance,
const gchar *detailed_signal,
GCallback c_handler,
gpointer data,
GClosureNotify destroy_data,
GConnectFlags connect_flags);
guint (*g_signal_handlers_block_matched) (gpointer instance,
GSignalMatchType mask,
guint signal_id,
GQuark detail,
GClosure *closure,
gpointer func,
gpointer data);
guint (*g_signal_handlers_unblock_matched) (gpointer instance,
GSignalMatchType mask,
guint signal_id,
GQuark detail,
GClosure *closure,
gpointer func,
gpointer data);
// gobject.h
typedef gpointer (*g_object_get_data_ptr) (GObject *object, const gchar *key);
typedef void (*g_object_set_data_ptr) (GObject *object, const gchar *key, gpointer data);
typedef void (*g_object_set_data_full_ptr) (GObject *object, const gchar *key, gpointer data, GDestroyNotify destroy);
typedef void (*g_object_unref_ptr) (gpointer object);
 
// gtype.h
GTypeInstance* (*g_type_check_instance_cast) (GTypeInstance *instance,
GType iface_type);
// gsignal.h
typedef gulong (*g_signal_connect_data_ptr) (gpointer instance, const gchar *detailed_signal, GCallback c_handler, gpointer data, GClosureNotify destroy_data, GConnectFlags connect_flags);
typedef guint (*g_signal_handlers_block_matched_ptr) (gpointer instance, GSignalMatchType mask, guint signal_id, GQuark detail, GClosure *closure, gpointer func, gpointer data);
typedef guint (*g_signal_handlers_unblock_matched_ptr) (gpointer instance, GSignalMatchType mask, guint signal_id, GQuark detail, GClosure *closure, gpointer func, gpointer data);
 
// gdk-pixdata.h
GdkPixbuf* (*gdk_pixbuf_from_pixdata) (const GdkPixdata *pixdata,
gboolean copy_pixels,
GError **error);
// gtype.h
typedef GTypeInstance* (*g_type_check_instance_cast_ptr) (GTypeInstance *instance, GType iface_type);
 
// gdk-pixbuf-core.h
GdkPixbuf *(*gdk_pixbuf_new_from_data) (const guchar *data,
GdkColorspace colorspace,
gboolean has_alpha,
int32_t bits_per_sample,
int32_t width, int32_t height,
int32_t rowstride,
GdkPixbufDestroyNotify destroy_fn,
gpointer destroy_fn_data);
// gdk-pixdata.h
typedef GdkPixbuf* (*gdk_pixbuf_from_pixdata_ptr) (const GdkPixdata *pixdata, gboolean copy_pixels, GError **error);
 
// gtkaccelgroup.h
GtkAccelGroup* (*gtk_accel_group_new) (void);
// gdk-pixbuf-core.h
typedef GdkPixbuf *(*gdk_pixbuf_new_from_data_ptr) (const guchar *data, GdkColorspace colorspace, gboolean has_alpha, int32_t bits_per_sample, int32_t width, int32_t height, int32_t rowstride, GdkPixbufDestroyNotify destroy_fn, gpointer destroy_fn_data);
 
// gtkalignment.h
GtkWidget* (*gtk_alignment_new) (gfloat xalign,
gfloat yalign,
gfloat xscale,
gfloat yscale);
// gtkaccelgroup.h
typedef GtkAccelGroup* (*gtk_accel_group_new_ptr) (void);
 
// gtkbox.h
GType (*gtk_box_get_type) (void) G_GNUC_CONST;
void (*gtk_box_pack_start) (GtkBox *box,
GtkWidget *child,
gboolean expand,
gboolean fill,
guint padding);
// gtkalignment.h
typedef GtkWidget* (*gtk_alignment_new_ptr) (gfloat xalign, gfloat yalign, gfloat xscale, gfloat yscale);
 
// gtkbbox.h
GType (*gtk_button_box_get_type) (void) G_GNUC_CONST;
void (*gtk_button_box_set_layout) (GtkButtonBox *widget,
GtkButtonBoxStyle layout_style);
// gtkbox.h
typedef GType (*gtk_box_get_type_ptr) (void) G_GNUC_CONST;
typedef void (*gtk_box_pack_start_ptr) (GtkBox *box, GtkWidget *child, gboolean expand, gboolean fill, guint padding);
 
// gtkbutton.h
GtkWidget* (*gtk_button_new) (void);
// gtkbbox.h
typedef GType (*gtk_button_box_get_type_ptr) (void) G_GNUC_CONST;
typedef void (*gtk_button_box_set_layout_ptr) (GtkButtonBox *widget, GtkButtonBoxStyle layout_style);
 
// gtkcelllayout.h
GType (*gtk_cell_layout_get_type) (void) G_GNUC_CONST;
void (*gtk_cell_layout_pack_start) (GtkCellLayout *cell_layout,
GtkCellRenderer *cell,
gboolean expand);
void (*gtk_cell_layout_set_attributes) (GtkCellLayout *cell_layout,
GtkCellRenderer *cell,
...) G_GNUC_NULL_TERMINATED;
// gtkbutton.h
typedef GtkWidget* (*gtk_button_new_ptr) (void);
 
// gtkcellrenderertext.h
GtkCellRenderer *(*gtk_cell_renderer_text_new) (void);
// gtkcelllayout.h
typedef GType (*gtk_cell_layout_get_type_ptr) (void) G_GNUC_CONST;
typedef void (*gtk_cell_layout_pack_start_ptr) (GtkCellLayout *cell_layout, GtkCellRenderer *cell, gboolean expand);
typedef void (*gtk_cell_layout_set_attributes_ptr) (GtkCellLayout *cell_layout, GtkCellRenderer *cell, ...) G_GNUC_NULL_TERMINATED;
 
// gtkcheckbutton.h
GtkWidget* (*gtk_check_button_new_with_mnemonic) (const gchar *label);
// gtkcellrenderertext.h
typedef GtkCellRenderer *(*gtk_cell_renderer_text_new_ptr) (void);
 
// gtkcombobox.h
gint (*gtk_combo_box_get_active) (GtkComboBox *combo_box);
gboolean (*gtk_combo_box_get_active_iter) (GtkComboBox *combo_box,
GtkTreeIter *iter);
gchar (*gtk_combo_box_get_active_text) (GtkComboBox *combo_box);
GtkTreeModel *(*gtk_combo_box_get_model) (GtkComboBox *combo_box);
GType (*gtk_combo_box_get_type) (void) G_GNUC_CONST;
GtkWidget *(*gtk_combo_box_new_text) (void);
GtkWidget *(*gtk_combo_box_new_with_model) (GtkTreeModel *model);
void (*gtk_combo_box_set_active) (GtkComboBox *combo_box,
gint index_);
void (*gtk_combo_box_set_active_iter) (GtkComboBox *combo_box,
GtkTreeIter *iter);
// gtkcheckbutton.h
typedef GtkWidget* (*gtk_check_button_new_with_mnemonic_ptr) (const gchar *label);
 
// gtkcontainer.h
void (*gtk_container_add) (GtkContainer *container,
GtkWidget *widget);
void (*gtk_container_foreach) (GtkContainer *container,
GtkCallback callback,
gpointer callback_data);
GType (*gtk_container_get_type) (void) G_GNUC_CONST;
void (*gtk_container_set_border_width) (GtkContainer *container,
guint border_width);
// gtkcombobox.h
typedef gint (*gtk_combo_box_get_active_ptr) (GtkComboBox *combo_box);
typedef gboolean (*gtk_combo_box_get_active_iter_ptr) (GtkComboBox *combo_box, GtkTreeIter *iter);
typedef gchar (*gtk_combo_box_get_active_text_ptr) (GtkComboBox *combo_box);
typedef GtkTreeModel *(*gtk_combo_box_get_model_ptr) (GtkComboBox *combo_box);
typedef GType (*gtk_combo_box_get_type_ptr) (void) G_GNUC_CONST;
typedef GtkWidget *(*gtk_combo_box_new_text_ptr) (void);
typedef GtkWidget *(*gtk_combo_box_new_with_model_ptr) (GtkTreeModel *model);
typedef void (*gtk_combo_box_set_active_ptr) (GtkComboBox *combo_box, gint index_);
typedef void (*gtk_combo_box_set_active_iter_ptr) (GtkComboBox *combo_box, GtkTreeIter *iter);
 
// gtkdialog.h
GType (*gtk_dialog_get_type) (void) G_GNUC_CONST;
gint (*gtk_dialog_run) (GtkDialog *dialog);
// gtkcontainer.h
typedef void (*gtk_container_add_ptr) (GtkContainer *container, GtkWidget *widget);
typedef void (*gtk_container_foreach_ptr) (GtkContainer *container, GtkCallback callback, gpointer callback_data);
typedef GType (*gtk_container_get_type_ptr) (void) G_GNUC_CONST;
typedef void (*gtk_container_set_border_width_ptr) (GtkContainer *container, guint border_width);
 
// gtkhbox.h
GtkWidget* (*gtk_hbox_new) (gboolean homogeneous,
gint spacing);
// gtkdialog.h
typedef GType (*gtk_dialog_get_type_ptr) (void) G_GNUC_CONST;
typedef gint (*gtk_dialog_run_ptr) (GtkDialog *dialog);
 
// gtkhbbox.h
GtkWidget* (*gtk_hbutton_box_new) (void);
// gtkhbox.h
typedef GtkWidget* (*gtk_hbox_new_ptr) (gboolean homogeneous, gint spacing);
 
// gtkimage.h
GtkWidget* (*gtk_image_new_from_pixbuf) (GdkPixbuf *pixbuf);
GtkWidget* (*gtk_image_new_from_stock) (const gchar *stock_id,
GtkIconSize size);
// gtkhbbox.h
typedef GtkWidget* (*gtk_hbutton_box_new_ptr) (void);
 
// gtkmain.h
gboolean (*gtk_init_check) (int32_t *argc,
char ***argv);
// gtkimage.h
typedef GtkWidget* (*gtk_image_new_from_pixbuf_ptr) (GdkPixbuf *pixbuf);
typedef GtkWidget* (*gtk_image_new_from_stock_ptr) (const gchar *stock_id, GtkIconSize size);
 
// gtklabel.h
GType (*gtk_label_get_type) (void) G_GNUC_CONST;
GtkWidget* (*gtk_label_new) (const gchar *str);
GtkWidget* (*gtk_label_new_with_mnemonic) (const gchar *str);
void (*gtk_label_set_mnemonic_widget) (GtkLabel *label,
GtkWidget *widget);
// gtkmain.h
typedef gboolean (*gtk_init_check_ptr) (int32_t *argc, char ***argv);
 
// gtkliststore.h
void (*gtk_list_store_append) (GtkListStore *list_store,
GtkTreeIter *iter);
void (*gtk_list_store_clear) (GtkListStore *list_store);
GType (*gtk_list_store_get_type) (void) G_GNUC_CONST;
GtkListStore *(*gtk_list_store_new) (gint n_columns,
...);
void (*gtk_list_store_set) (GtkListStore *list_store,
GtkTreeIter *iter,
...);
// gtklabel.h
typedef GType (*gtk_label_get_type_ptr) (void) G_GNUC_CONST;
typedef GtkWidget* (*gtk_label_new_ptr) (const gchar *str);
typedef GtkWidget* (*gtk_label_new_with_mnemonic_ptr) (const gchar *str);
typedef void (*gtk_label_set_mnemonic_widget_ptr) (GtkLabel *label, GtkWidget *widget);
 
// gtkmain.h
void (*gtk_main) (void);
gboolean (*gtk_main_iteration_do) (gboolean blocking);
void (*gtk_main_quit) (void);
// gtkliststore.h
typedef void (*gtk_list_store_append_ptr) (GtkListStore *list_store, GtkTreeIter *iter);
typedef void (*gtk_list_store_clear_ptr) (GtkListStore *list_store);
typedef GType (*gtk_list_store_get_type_ptr) (void) G_GNUC_CONST;
typedef GtkListStore *(*gtk_list_store_new_ptr) (gint n_columns, ...);
typedef void (*gtk_list_store_set_ptr) (GtkListStore *list_store, GtkTreeIter *iter, ...);
 
// gtkmessagedialog.h
GtkWidget* (*gtk_message_dialog_new) (GtkWindow *parent,
GtkDialogFlags flags,
GtkMessageType type,
GtkButtonsType buttons,
const gchar *message_format,
...) G_GNUC_PRINTF (5, 6);
// gtkmain.h
typedef void (*gtk_main_ptr) (void);
typedef gboolean (*gtk_main_iteration_do_ptr) (gboolean blocking);
typedef void (*gtk_main_quit_ptr) (void);
 
// gtkmisc.h
GType (*gtk_misc_get_type) (void) G_GNUC_CONST;
void (*gtk_misc_set_alignment) (GtkMisc *misc,
gfloat xalign,
gfloat yalign);
// gtkmessagedialog.h
typedef GtkWidget* (*gtk_message_dialog_new_ptr) (GtkWindow *parent, GtkDialogFlags flags, GtkMessageType type, GtkButtonsType buttons, const gchar *message_format, ...) G_GNUC_PRINTF (5, 6);
 
// gtknotebook.h
GtkWidget* (*gtk_notebook_get_nth_page) (GtkNotebook *notebook,
gint page_num);
GType (*gtk_notebook_get_type) (void) G_GNUC_CONST;
GtkWidget * (*gtk_notebook_new) (void);
void (*gtk_notebook_set_current_page) (GtkNotebook *notebook,
gint page_num);
void (*gtk_notebook_set_tab_label) (GtkNotebook *notebook,
GtkWidget *child,
GtkWidget *tab_label);
// gtkmisc.h
typedef GType (*gtk_misc_get_type_ptr) (void) G_GNUC_CONST;
typedef void (*gtk_misc_set_alignment_ptr) (GtkMisc *misc, gfloat xalign, gfloat yalign);
 
// gtkobject.h
GtkType (*gtk_object_get_type) (void) G_GNUC_CONST;
// gtknotebook.h
typedef GtkWidget* (*gtk_notebook_get_nth_page_ptr) (GtkNotebook *notebook, gint page_num);
typedef GType (*gtk_notebook_get_type_ptr) (void) G_GNUC_CONST;
typedef GtkWidget * (*gtk_notebook_new_ptr) (void);
typedef void (*gtk_notebook_set_current_page_ptr) (GtkNotebook *notebook, gint page_num);
typedef void (*gtk_notebook_set_tab_label_ptr) (GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label);
 
// gtkscrolledwindow.h
GType (*gtk_scrolled_window_get_type) (void) G_GNUC_CONST;
GtkWidget* (*gtk_scrolled_window_new) (GtkAdjustment *hadjustment,
GtkAdjustment *vadjustment);
void (*gtk_scrolled_window_set_policy) (GtkScrolledWindow *scrolled_window,
GtkPolicyType hscrollbar_policy,
GtkPolicyType vscrollbar_policy);
void (*gtk_scrolled_window_set_shadow_type) (GtkScrolledWindow *scrolled_window,
GtkShadowType type);
// gtktable.h
GType (*gtk_table_get_type) (void) G_GNUC_CONST;
GtkWidget* (*gtk_table_new) (guint rows,
guint columns,
gboolean homogeneous);
void (*gtk_table_attach) (GtkTable *table,
GtkWidget *child,
guint left_attach,
guint right_attach,
guint top_attach,
guint bottom_attach,
GtkAttachOptions xoptions,
GtkAttachOptions yoptions,
guint xpadding,
guint ypadding);
// gtkobject.h
typedef GtkType (*gtk_object_get_type_ptr) (void) G_GNUC_CONST;
 
// gtkscrolledwindow.h
typedef GType (*gtk_scrolled_window_get_type_ptr) (void) G_GNUC_CONST;
typedef GtkWidget* (*gtk_scrolled_window_new_ptr) (GtkAdjustment *hadjustment, GtkAdjustment *vadjustment);
typedef void (*gtk_scrolled_window_set_policy_ptr) (GtkScrolledWindow *scrolled_window, GtkPolicyType hscrollbar_policy, GtkPolicyType vscrollbar_policy);
typedef void (*gtk_scrolled_window_set_shadow_type_ptr) (GtkScrolledWindow *scrolled_window, GtkShadowType type);
 
// gtktextbuffer.h
gboolean (*gtk_text_buffer_backspace) (GtkTextBuffer *buffer,
GtkTextIter *iter,
gboolean interactive,
gboolean default_editable);
GtkTextMark *(*gtk_text_buffer_create_mark) (GtkTextBuffer *buffer,
const gchar *mark_name,
const GtkTextIter *where,
gboolean left_gravity);
void (*gtk_text_buffer_delete_mark) (GtkTextBuffer *buffer,
GtkTextMark *mark);
void (*gtk_text_buffer_get_end_iter) (GtkTextBuffer *buffer,
GtkTextIter *iter);
void (*gtk_text_buffer_insert) (GtkTextBuffer *buffer,
GtkTextIter *iter,
const gchar *text,
gint len);
// gtktable.h
typedef GType (*gtk_table_get_type_ptr) (void) G_GNUC_CONST;
typedef GtkWidget* (*gtk_table_new_ptr) (guint rows, guint columns, gboolean homogeneous);
typedef void (*gtk_table_attach_ptr) (GtkTable *table, GtkWidget *child, guint left_attach, guint right_attach, guint top_attach, guint bottom_attach, GtkAttachOptions xoptions, GtkAttachOptions yoptions, guint xpadding, guint ypadding);
 
// gtktextiter.h
// FIXME: should I put a #if !GTK_CHECK_VERSION(2,6,0)
// around these three, or should I not care?
gboolean (*gtk_text_iter_backward_cursor_position) (GtkTextIter *iter);
gboolean (*gtk_text_iter_equal) (const GtkTextIter *lhs,
const GtkTextIter *rhs);
gboolean (*gtk_text_buffer_delete_interactive) (GtkTextBuffer *buffer,
GtkTextIter *start_iter,
GtkTextIter *end_iter,
gboolean default_editable);
// gtktextbuffer.h
typedef gboolean (*gtk_text_buffer_backspace_ptr) (GtkTextBuffer *buffer, GtkTextIter *iter, gboolean interactive, gboolean default_editable);
typedef GtkTextMark *(*gtk_text_buffer_create_mark_ptr) (GtkTextBuffer *buffer, const gchar *mark_name, const GtkTextIter *where, gboolean left_gravity);
typedef void (*gtk_text_buffer_delete_mark_ptr) (GtkTextBuffer *buffer, GtkTextMark *mark);
typedef void (*gtk_text_buffer_get_end_iter_ptr) (GtkTextBuffer *buffer, GtkTextIter *iter);
typedef void (*gtk_text_buffer_insert_ptr) (GtkTextBuffer *buffer, GtkTextIter *iter, const gchar *text, gint len);
 
// gtktextview.h
GtkTextBuffer *(*gtk_text_view_get_buffer) (GtkTextView *text_view);
GType (*gtk_text_view_get_type) (void) G_GNUC_CONST;
GtkWidget * (*gtk_text_view_new) (void);
void (*gtk_text_view_scroll_to_mark) (GtkTextView *text_view,
GtkTextMark *mark,
gdouble within_margin,
gboolean use_align,
gdouble xalign,
gdouble yalign);
void (*gtk_text_view_set_cursor_visible) (GtkTextView *text_view,
gboolean setting);
void (*gtk_text_view_set_editable) (GtkTextView *text_view,
gboolean setting);
void (*gtk_text_view_set_left_margin) (GtkTextView *text_view,
gint left_margin);
void (*gtk_text_view_set_right_margin) (GtkTextView *text_view,
gint right_margin);
void (*gtk_text_view_set_wrap_mode) (GtkTextView *text_view,
GtkWrapMode wrap_mode);
// gtktextiter.h
// FIXME: should I put a #if !GTK_CHECK_VERSION(2,6,0)
// around these three, or should I not care?
typedef gboolean (*gtk_text_iter_backward_cursor_position_ptr) (GtkTextIter *iter);
typedef gboolean (*gtk_text_iter_equal_ptr) (const GtkTextIter *lhs, const GtkTextIter *rhs);
typedef gboolean (*gtk_text_buffer_delete_interactive_ptr) (GtkTextBuffer *buffer, GtkTextIter *start_iter, GtkTextIter *end_iter, gboolean default_editable);
 
// gtktogglebutton.h
gboolean (*gtk_toggle_button_get_active) (GtkToggleButton *toggle_button);
GType (*gtk_toggle_button_get_type) (void) G_GNUC_CONST;
void (*gtk_toggle_button_set_active) (GtkToggleButton *toggle_button,
gboolean is_active);
// gtktextview.h
typedef GtkTextBuffer *(*gtk_text_view_get_buffer_ptr) (GtkTextView *text_view);
typedef GType (*gtk_text_view_get_type_ptr) (void) G_GNUC_CONST;
typedef GtkWidget * (*gtk_text_view_new_ptr) (void);
typedef void (*gtk_text_view_scroll_to_mark_ptr) (GtkTextView *text_view, GtkTextMark *mark, gdouble within_margin, gboolean use_align, gdouble xalign, gdouble yalign);
typedef void (*gtk_text_view_set_cursor_visible_ptr) (GtkTextView *text_view, gboolean setting);
typedef void (*gtk_text_view_set_editable_ptr) (GtkTextView *text_view, gboolean setting);
typedef void (*gtk_text_view_set_left_margin_ptr) (GtkTextView *text_view, gint left_margin);
typedef void (*gtk_text_view_set_right_margin_ptr) (GtkTextView *text_view, gint right_margin);
typedef void (*gtk_text_view_set_wrap_mode_ptr) (GtkTextView *text_view, GtkWrapMode wrap_mode);
 
// gtktreemodel.h
void (*gtk_tree_model_get) (GtkTreeModel *tree_model,
GtkTreeIter *iter,
...);
gboolean (*gtk_tree_model_get_iter) (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreePath *path);
GtkTreePath * (*gtk_tree_model_get_path) (GtkTreeModel *tree_model,
GtkTreeIter *iter);
GType (*gtk_tree_model_get_type) (void) G_GNUC_CONST;
gint *(*gtk_tree_path_get_indices) (GtkTreePath *path);
GtkTreePath *(*gtk_tree_path_new_from_indices) (gint first_index,
...);
// gtktreeselection.h
gboolean (*gtk_tree_selection_get_selected) (GtkTreeSelection *selection,
GtkTreeModel **model,
GtkTreeIter *iter);
void (*gtk_tree_selection_select_iter) (GtkTreeSelection *selection,
GtkTreeIter *iter);
GType (*gtk_tree_selection_get_type) (void) G_GNUC_CONST;
// gtktogglebutton.h
typedef gboolean (*gtk_toggle_button_get_active_ptr) (GtkToggleButton *toggle_button);
typedef GType (*gtk_toggle_button_get_type_ptr) (void) G_GNUC_CONST;
typedef void (*gtk_toggle_button_set_active_ptr) (GtkToggleButton *toggle_button, gboolean is_active);
 
void (*gtk_tree_selection_set_mode) (GtkTreeSelection *selection,
GtkSelectionMode type);
// gtktreemodel.h
typedef void (*gtk_tree_model_get_ptr) (GtkTreeModel *tree_model, GtkTreeIter *iter, ...);
typedef gboolean (*gtk_tree_model_get_iter_ptr) (GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreePath *path);
typedef GtkTreePath * (*gtk_tree_model_get_path_ptr) (GtkTreeModel *tree_model, GtkTreeIter *iter);
typedef GType (*gtk_tree_model_get_type_ptr) (void) G_GNUC_CONST;
typedef gint *(*gtk_tree_path_get_indices_ptr) (GtkTreePath *path);
typedef GtkTreePath *(*gtk_tree_path_new_from_indices_ptr) (gint first_index, ...);
 
// gtktreesortable.h
GType (*gtk_tree_sortable_get_type) (void) G_GNUC_CONST;
// gtktreeselection.h
typedef gboolean (*gtk_tree_selection_get_selected_ptr) (GtkTreeSelection *selection, GtkTreeModel **model, GtkTreeIter *iter);
typedef void (*gtk_tree_selection_select_iter_ptr) (GtkTreeSelection *selection, GtkTreeIter *iter);
typedef GType (*gtk_tree_selection_get_type_ptr) (void) G_GNUC_CONST;
typedef void (*gtk_tree_selection_set_mode_ptr) (GtkTreeSelection *selection, GtkSelectionMode type);
 
void (*gtk_tree_sortable_set_sort_column_id) (GtkTreeSortable *sortable,
gint sort_column_id,
GtkSortType order);
void (*gtk_tree_sortable_set_sort_func) (GtkTreeSortable *sortable,
gint sort_column_id,
GtkTreeIterCompareFunc sort_func,
gpointer user_data,
GtkDestroyNotify destroy);
// gtktreesortable.h
typedef GType (*gtk_tree_sortable_get_type_ptr) (void) G_GNUC_CONST;
typedef void (*gtk_tree_sortable_set_sort_column_id_ptr) (GtkTreeSortable *sortable, gint sort_column_id, GtkSortType order);
typedef void (*gtk_tree_sortable_set_sort_func_ptr) (GtkTreeSortable *sortable, gint sort_column_id, GtkTreeIterCompareFunc sort_func, gpointer user_data, GtkDestroyNotify destroy);
 
// gtktreeview.h
GType (*gtk_tree_view_get_type) (void) G_GNUC_CONST;
GtkWidget *(*gtk_tree_view_new_with_model) (GtkTreeModel *model);
// gtktreeview.h
typedef GType (*gtk_tree_view_get_type_ptr) (void) G_GNUC_CONST;
typedef GtkWidget *(*gtk_tree_view_new_with_model_ptr) (GtkTreeModel *model);
typedef GtkTreeModel *(*gtk_tree_view_get_model_ptr) (GtkTreeView *tree_view);
typedef GtkTreeSelection *(*gtk_tree_view_get_selection_ptr) (GtkTreeView *tree_view);
typedef gint (*gtk_tree_view_append_column_ptr) (GtkTreeView *tree_view, GtkTreeViewColumn *column);
typedef void (*gtk_tree_view_set_enable_search_ptr) (GtkTreeView *tree_view, gboolean enable_search);
typedef void (*gtk_tree_view_set_headers_visible_ptr) (GtkTreeView *tree_view, gboolean headers_visible);
 
GtkTreeModel *(*gtk_tree_view_get_model) (GtkTreeView *tree_view);
// gtktreeviewcolumn.h
typedef GtkTreeViewColumn *(*gtk_tree_view_column_new_with_attributes_ptr) (const gchar *title, GtkCellRenderer *cell, ...) G_GNUC_NULL_TERMINATED;
typedef void (*gtk_tree_view_column_set_expand_ptr) (GtkTreeViewColumn *tree_column, gboolean expand);
typedef void (*gtk_tree_view_column_set_min_width_ptr) (GtkTreeViewColumn *tree_column, gint min_width);
 
GtkTreeSelection *(*gtk_tree_view_get_selection) (GtkTreeView *tree_view);
gint (*gtk_tree_view_append_column) (GtkTreeView *tree_view,
GtkTreeViewColumn *column);
void (*gtk_tree_view_set_enable_search) (GtkTreeView *tree_view,
gboolean enable_search);
void (*gtk_tree_view_set_headers_visible) (GtkTreeView *tree_view,
gboolean headers_visible);
// gtkvbox.h
typedef GtkWidget* (*gtk_vbox_new_ptr) (gboolean homogeneous, gint spacing);
 
// gtktreeviewcolumn.h
GtkTreeViewColumn *(*gtk_tree_view_column_new_with_attributes) (const gchar *title,
GtkCellRenderer *cell,
...) G_GNUC_NULL_TERMINATED;
void (*gtk_tree_view_column_set_expand) (GtkTreeViewColumn *tree_column,
gboolean expand);
void (*gtk_tree_view_column_set_min_width) (GtkTreeViewColumn *tree_column,
gint min_width);
// gtkwidget.h
typedef void (*gtk_widget_add_accelerator_ptr) (GtkWidget *widget, const gchar *accel_signal, GtkAccelGroup *accel_group, guint accel_key, GdkModifierType accel_mods, GtkAccelFlags accel_flags);
typedef void (*gtk_widget_destroy_ptr) (GtkWidget *widget);
typedef GtkWidget* (*gtk_widget_ref_ptr) (GtkWidget *widget);
typedef void (*gtk_widget_set_sensitive_ptr) (GtkWidget *widget, gboolean sensitive);
typedef void (*gtk_widget_set_size_request_ptr) (GtkWidget *widget, gint width, gint height);
typedef void (*gtk_widget_show_all_ptr) (GtkWidget *widget);
typedef void (*gtk_widget_unref_ptr) (GtkWidget *widget);
 
// gtkwindow.h
typedef void (*gtk_window_add_accel_group_ptr) (GtkWindow *window, GtkAccelGroup *accel_group);
typedef GType (*gtk_window_get_type_ptr) (void) G_GNUC_CONST;
typedef GtkWidget* (*gtk_window_new_ptr) (GtkWindowType type);
typedef void (*gtk_window_set_default_icon_ptr) (GdkPixbuf *icon);
typedef void (*gtk_window_set_position_ptr) (GtkWindow *window, GtkWindowPosition position);
typedef void (*gtk_window_set_resizable_ptr) (GtkWindow *window, gboolean resizable);
typedef void (*gtk_window_set_title_ptr) (GtkWindow *window, const gchar *title);
typedef void (*gtk_window_set_type_hint_ptr) (GtkWindow *window, GdkWindowTypeHint hint);
typedef void (*gtk_window_set_default_ptr) (GtkWindow *window, GtkWidget *default_widget);
 
// gtkvbox.h
GtkWidget* (*gtk_vbox_new) (gboolean homogeneous,
gint spacing);
// gunicode.h
typedef gint (*g_utf8_collate_ptr) (const gchar *str1, const gchar *str2);
 
// gtkwidget.h
void (*gtk_widget_add_accelerator) (GtkWidget *widget,
const gchar *accel_signal,
GtkAccelGroup *accel_group,
guint accel_key,
GdkModifierType accel_mods,
GtkAccelFlags accel_flags);
void (*gtk_widget_destroy) (GtkWidget *widget);
GtkWidget* (*gtk_widget_ref) (GtkWidget *widget);
void (*gtk_widget_set_sensitive) (GtkWidget *widget,
gboolean sensitive);
void (*gtk_widget_set_size_request) (GtkWidget *widget,
gint width,
gint height);
void (*gtk_widget_show_all) (GtkWidget *widget);
void (*gtk_widget_unref) (GtkWidget *widget);
 
// gtkwindow.h
void (*gtk_window_add_accel_group) (GtkWindow *window,
GtkAccelGroup *accel_group);
GType (*gtk_window_get_type) (void) G_GNUC_CONST;
GtkWidget* (*gtk_window_new) (GtkWindowType type);
void (*gtk_window_set_default_icon) (GdkPixbuf *icon);
void (*gtk_window_set_position) (GtkWindow *window,
GtkWindowPosition position);
void (*gtk_window_set_resizable) (GtkWindow *window,
gboolean resizable);
void (*gtk_window_set_title) (GtkWindow *window,
const gchar *title);
void (*gtk_window_set_type_hint) (GtkWindow *window,
GdkWindowTypeHint hint);
void (*gtk_window_set_default) (GtkWindow *window,
GtkWidget *default_widget);
 
// gunicode.h
gint (*g_utf8_collate) (const gchar *str1,
const gchar *str2);
 
struct _dynamicgtksyms {
g_free_ptr g_free;
g_object_get_data_ptr g_object_get_data;
g_object_set_data_ptr g_object_set_data;
g_object_set_data_full_ptr g_object_set_data_full;
g_object_unref_ptr g_object_unref;
g_signal_connect_data_ptr g_signal_connect_data;
g_signal_handlers_block_matched_ptr g_signal_handlers_block_matched;
g_signal_handlers_unblock_matched_ptr g_signal_handlers_unblock_matched;
g_type_check_instance_cast_ptr g_type_check_instance_cast;
gdk_pixbuf_from_pixdata_ptr gdk_pixbuf_from_pixdata;
gdk_pixbuf_new_from_data_ptr gdk_pixbuf_new_from_data;
gtk_accel_group_new_ptr gtk_accel_group_new;
gtk_alignment_new_ptr gtk_alignment_new;
gtk_box_get_type_ptr gtk_box_get_type;
gtk_box_pack_start_ptr gtk_box_pack_start;
gtk_button_box_get_type_ptr gtk_button_box_get_type;
gtk_button_box_set_layout_ptr gtk_button_box_set_layout;
gtk_button_new_ptr gtk_button_new;
gtk_cell_layout_get_type_ptr gtk_cell_layout_get_type;
gtk_cell_layout_pack_start_ptr gtk_cell_layout_pack_start;
gtk_cell_layout_set_attributes_ptr gtk_cell_layout_set_attributes;
gtk_cell_renderer_text_new_ptr gtk_cell_renderer_text_new;
gtk_check_button_new_with_mnemonic_ptr gtk_check_button_new_with_mnemonic;
gtk_combo_box_get_active_ptr gtk_combo_box_get_active;
gtk_combo_box_get_active_iter_ptr gtk_combo_box_get_active_iter;
gtk_combo_box_get_active_text_ptr gtk_combo_box_get_active_text;
gtk_combo_box_get_model_ptr gtk_combo_box_get_model;
gtk_combo_box_get_type_ptr gtk_combo_box_get_type;
gtk_combo_box_new_text_ptr gtk_combo_box_new_text;
gtk_combo_box_new_with_model_ptr gtk_combo_box_new_with_model;
gtk_combo_box_set_active_ptr gtk_combo_box_set_active;
gtk_combo_box_set_active_iter_ptr gtk_combo_box_set_active_iter;
gtk_container_add_ptr gtk_container_add;
gtk_container_foreach_ptr gtk_container_foreach;
gtk_container_get_type_ptr gtk_container_get_type;
gtk_container_set_border_width_ptr gtk_container_set_border_width;
gtk_dialog_get_type_ptr gtk_dialog_get_type;
gtk_dialog_run_ptr gtk_dialog_run;
gtk_hbox_new_ptr gtk_hbox_new;
gtk_hbutton_box_new_ptr gtk_hbutton_box_new;
gtk_image_new_from_pixbuf_ptr gtk_image_new_from_pixbuf;
gtk_image_new_from_stock_ptr gtk_image_new_from_stock;
gtk_init_check_ptr gtk_init_check;
gtk_label_get_type_ptr gtk_label_get_type;
gtk_label_new_ptr gtk_label_new;
gtk_label_new_with_mnemonic_ptr gtk_label_new_with_mnemonic;
gtk_label_set_mnemonic_widget_ptr gtk_label_set_mnemonic_widget;
gtk_list_store_append_ptr gtk_list_store_append;
gtk_list_store_clear_ptr gtk_list_store_clear;
gtk_list_store_get_type_ptr gtk_list_store_get_type;
gtk_list_store_new_ptr gtk_list_store_new;
gtk_list_store_set_ptr gtk_list_store_set;
gtk_main_ptr gtk_main;
gtk_main_iteration_do_ptr gtk_main_iteration_do;
gtk_main_quit_ptr gtk_main_quit;
gtk_message_dialog_new_ptr gtk_message_dialog_new;
gtk_misc_get_type_ptr gtk_misc_get_type;
gtk_misc_set_alignment_ptr gtk_misc_set_alignment;
gtk_notebook_get_nth_page_ptr gtk_notebook_get_nth_page;
gtk_notebook_get_type_ptr gtk_notebook_get_type;
gtk_notebook_new_ptr gtk_notebook_new;
gtk_notebook_set_current_page_ptr gtk_notebook_set_current_page;
gtk_notebook_set_tab_label_ptr gtk_notebook_set_tab_label;
gtk_object_get_type_ptr gtk_object_get_type;
gtk_scrolled_window_get_type_ptr gtk_scrolled_window_get_type;
gtk_scrolled_window_new_ptr gtk_scrolled_window_new;
gtk_scrolled_window_set_policy_ptr gtk_scrolled_window_set_policy;
gtk_scrolled_window_set_shadow_type_ptr gtk_scrolled_window_set_shadow_type;
gtk_table_get_type_ptr gtk_table_get_type;
gtk_table_new_ptr gtk_table_new;
gtk_table_attach_ptr gtk_table_attach;
gtk_text_buffer_backspace_ptr gtk_text_buffer_backspace;
gtk_text_buffer_create_mark_ptr gtk_text_buffer_create_mark;
gtk_text_buffer_delete_mark_ptr gtk_text_buffer_delete_mark;
gtk_text_buffer_get_end_iter_ptr gtk_text_buffer_get_end_iter;
gtk_text_buffer_insert_ptr gtk_text_buffer_insert;
// FIXME: should I put a #if !GTK_CHECK_VERSION(2,6,0)
// around these three, or should I not care?
gtk_text_iter_backward_cursor_position_ptr gtk_text_iter_backward_cursor_position;
gtk_text_iter_equal_ptr gtk_text_iter_equal;
gtk_text_buffer_delete_interactive_ptr gtk_text_buffer_delete_interactive;
//
gtk_text_view_get_buffer_ptr gtk_text_view_get_buffer;
gtk_text_view_get_type_ptr gtk_text_view_get_type;
gtk_text_view_new_ptr gtk_text_view_new;
gtk_text_view_scroll_to_mark_ptr gtk_text_view_scroll_to_mark;
gtk_text_view_set_cursor_visible_ptr gtk_text_view_set_cursor_visible;
gtk_text_view_set_editable_ptr gtk_text_view_set_editable;
gtk_text_view_set_left_margin_ptr gtk_text_view_set_left_margin;
gtk_text_view_set_right_margin_ptr gtk_text_view_set_right_margin;
gtk_text_view_set_wrap_mode_ptr gtk_text_view_set_wrap_mode;
gtk_toggle_button_get_active_ptr gtk_toggle_button_get_active;
gtk_toggle_button_get_type_ptr gtk_toggle_button_get_type;
gtk_toggle_button_set_active_ptr gtk_toggle_button_set_active;
gtk_tree_model_get_ptr gtk_tree_model_get;
gtk_tree_model_get_iter_ptr gtk_tree_model_get_iter;
gtk_tree_model_get_path_ptr gtk_tree_model_get_path;
gtk_tree_model_get_type_ptr gtk_tree_model_get_type;
gtk_tree_path_get_indices_ptr gtk_tree_path_get_indices;
gtk_tree_path_new_from_indices_ptr gtk_tree_path_new_from_indices;
gtk_tree_selection_get_selected_ptr gtk_tree_selection_get_selected;
gtk_tree_selection_select_iter_ptr gtk_tree_selection_select_iter;
gtk_tree_selection_set_mode_ptr gtk_tree_selection_set_mode;
gtk_tree_sortable_get_type_ptr gtk_tree_sortable_get_type;
gtk_tree_sortable_set_sort_column_id_ptr gtk_tree_sortable_set_sort_column_id;
gtk_tree_sortable_set_sort_func_ptr gtk_tree_sortable_set_sort_func;
gtk_tree_view_append_column_ptr gtk_tree_view_append_column;
gtk_tree_view_column_new_with_attributes_ptr gtk_tree_view_column_new_with_attributes;
gtk_tree_view_column_set_expand_ptr gtk_tree_view_column_set_expand;
gtk_tree_view_column_set_min_width_ptr gtk_tree_view_column_set_min_width;
gtk_tree_view_get_model_ptr gtk_tree_view_get_model;
gtk_tree_view_get_selection_ptr gtk_tree_view_get_selection;
gtk_tree_view_get_type_ptr gtk_tree_view_get_type;
gtk_tree_view_new_with_model_ptr gtk_tree_view_new_with_model;
gtk_tree_view_set_enable_search_ptr gtk_tree_view_set_enable_search;
gtk_tree_view_set_headers_visible_ptr gtk_tree_view_set_headers_visible;
gtk_vbox_new_ptr gtk_vbox_new;
gtk_widget_add_accelerator_ptr gtk_widget_add_accelerator;
gtk_widget_destroy_ptr gtk_widget_destroy;
gtk_widget_ref_ptr gtk_widget_ref;
gtk_widget_set_sensitive_ptr gtk_widget_set_sensitive;
gtk_widget_set_size_request_ptr gtk_widget_set_size_request;
gtk_widget_show_all_ptr gtk_widget_show_all;
gtk_widget_unref_ptr gtk_widget_unref;
gtk_window_add_accel_group_ptr gtk_window_add_accel_group;
gtk_window_get_type_ptr gtk_window_get_type;
gtk_window_new_ptr gtk_window_new;
gtk_window_set_default_icon_ptr gtk_window_set_default_icon;
gtk_window_set_position_ptr gtk_window_set_position;
gtk_window_set_resizable_ptr gtk_window_set_resizable;
gtk_window_set_title_ptr gtk_window_set_title;
gtk_window_set_type_hint_ptr gtk_window_set_type_hint;
gtk_window_set_default_ptr gtk_window_set_default;
g_utf8_collate_ptr g_utf8_collate;
};
extern struct _dynamicgtksyms dynamicgtksyms;
 
 
int32_t dynamicgtk_init(void);
void dynamicgtk_uninit(void);
 
/polymer/eduke32/build/src/dynamicgtk.c
9,7 → 9,7
struct _dynamicgtksyms dynamicgtksyms;
 
#define GETDLSYM(x) { \
dynamicgtksyms.x = dlsym(handle, (failsym = (const char *)#x)); \
dynamicgtksyms.x = (x ## _ptr) dlsym(handle, (failsym = (const char *)#x)); \
if (!dynamicgtksyms.x ) { err = 1; break; } \
}
 
187,3 → 187,4
handle = NULL;
memset(&dynamicgtksyms, 0, sizeof(dynamicgtksyms));
}