path: root/src/Gtk/Internal.icl

implementation module Gtk.Internal

import StdEnv
import StdMaybe
import StdDebug

import System._Pointer

import code from library "-lgtk-3"
import code from library "-lgdk-3"
import code from library "-lpangocairo-1.0"
import code from library "-lpango-1.0"
import code from library "-latk-1.0"
import code from library "-lcairo-gobject"
import code from library "-lcairo"
import code from library "-lgdk_pixbuf-2.0"
import code from library "-lgio-2.0"
import code from library "-lgobject-2.0"
import code from library "-lglib-2.0"

g_free :: !Pointer !.a -> .a
g_free p env = code {
	ccall g_free "p:V:A"
}

g_object_unref :: !Pointer !.a -> .a
g_object_unref p env = code {
	ccall g_object_unref "p:V:A"
}

g_signal_connect :: !Pointer !String !Pointer !Int !.a -> .a
g_signal_connect widget signal callback data env =
	g_signal_connect_data widget signal callback data 0 0 env

g_signal_connect_data :: !Pointer !String !Pointer !Int !Pointer !Int !.a -> .a
g_signal_connect_data widget signal callback data destroy_data flags env =
	connect widget (packString signal) callback data destroy_data flags env
where
	connect :: !Pointer !String !Pointer !Int !Pointer !Int !.a -> .a
	connect _ _ _ _ _ _ _ = code {
		ccall g_signal_connect_data "pspIpI:V:A"
	}

g_timeout_add :: !Int !Pointer !Int !.a -> .a
g_timeout_add interval address id env = code {
	ccall g_timeout_add "IpI:V:A"
}

g_timeout_add_seconds :: !Int !Pointer !Int !.a -> .a
g_timeout_add_seconds interval address id env = code {
	ccall g_timeout_add_seconds "IpI:V:A"
}

gtk_accel_group_new :: !.a -> (!Pointer, !.a)
gtk_accel_group_new env = code {
	ccall gtk_accel_group_new ":p:A"
}

gtk_action_bar_new :: !.a -> (!Pointer, !.a)
gtk_action_bar_new env = code {
	ccall gtk_action_bar_new ":p:A"
}

gtk_action_bar_pack_start :: !Pointer !Pointer !.a -> .a
gtk_action_bar_pack_start bar child env = code {
	ccall gtk_action_bar_pack_start "pp:V:A"
}

gtk_action_bar_pack_end :: !Pointer !Pointer !.a -> .a
gtk_action_bar_pack_end bar child env = code {
	ccall gtk_action_bar_pack_end "pp:V:A"
}

gtk_box_new :: !Bool !Int !.a -> (!Pointer, !.a)
gtk_box_new vertical spacing env = code {
	ccall gtk_box_new "II:p:A"
}

gtk_box_pack_start :: !Pointer !Pointer !Bool !Bool !Int !.a -> .a
gtk_box_pack_start box child expand fill spacing env = code {
	ccall gtk_box_pack_start "ppIII:V:A"
}

gtk_box_pack_end :: !Pointer !Pointer !Bool !Bool !Int !.a -> .a
gtk_box_pack_end box child expand fill spacing env = code {
	ccall gtk_box_pack_end "ppIII:V:A"
}

gtk_box_set_spacing :: !Pointer !Int !.a -> .a
gtk_box_set_spacing box spacing env = code {
	ccall gtk_box_set_spacing "pI:V:A"
}

gtk_button_new_from_icon_name :: !String !Int !.a -> (!Pointer, !.a)
gtk_button_new_from_icon_name name size env = new (packString name) size env
where
	new :: !String !Int !.a -> (!Pointer, !.a)
	new _ _ _ = code {
		ccall gtk_button_new_from_icon_name "sI:p:A"
	}

gtk_cell_renderer_text_new :: !.a -> (!Pointer, !.a)
gtk_cell_renderer_text_new env = code {
	ccall gtk_cell_renderer_text_new ":p:A"
}

gtk_check_menu_item_get_active :: !Pointer !.a -> (!Bool, !.a)
gtk_check_menu_item_get_active item env = code {
	ccall gtk_check_menu_item_get_active "p:I:A"
}

gtk_check_menu_item_new :: !.a -> (!Pointer, !.a)
gtk_check_menu_item_new env = code {
	ccall gtk_check_menu_item_new ":p:A"
}

gtk_check_menu_item_set_active :: !Pointer !Bool !.a -> .a
gtk_check_menu_item_set_active item setting env = code {
	ccall gtk_check_menu_item_set_active "GpI:V:A"
}

gtk_container_add :: !Pointer !Pointer !.a -> .a
gtk_container_add container widget env = code {
	ccall gtk_container_add "pp:V:A"
}

gtk_css_provider_new :: !.a -> (!Pointer, !.a)
gtk_css_provider_new env = code {
	ccall gtk_css_provider_new ":p:A"
}

// TODO: this relies on a deprecated return value; we should connect to the
// parsing-error signal instead.
gtk_css_provider_load_from_path :: !Pointer !String !Pointer !.a -> (!Bool, !.a)
gtk_css_provider_load_from_path provider path error env = load provider (packString path) error env
where
	load :: !Pointer !String !Pointer !.a -> (!Bool, !.a)
	load _ _ _ _ = code {
		ccall gtk_css_provider_load_from_path "psp:I:A"
	}

gtk_dialog_add_button :: !Pointer !String !Int !.a -> (!Pointer, !.a)
gtk_dialog_add_button dialog text response env = add dialog (packString text) response env
where
	add :: !Pointer !String !Int !.a -> (!Pointer, !.a)
	add _ _ _ _ = code {
		ccall gtk_dialog_add_button "psI:p:A"
	}

gtk_dialog_get_content_area :: !Pointer -> Pointer
gtk_dialog_get_content_area dialog = code {
	ccall gtk_dialog_get_content_area "p:p"
}

gtk_dialog_new :: !.a -> (!Pointer, !.a)
gtk_dialog_new env = code {
	ccall gtk_dialog_new ":p:A"
}

gtk_dialog_run :: !Pointer !.a -> (!Int, !.a)
gtk_dialog_run dialog env = code {
	ccall gtk_dialog_run "Gp:I:A"
}

gtk_dialog_set_default_response :: !Pointer !Int !.a -> .a
gtk_dialog_set_default_response dialog response env = code {
	ccall gtk_dialog_set_default_response "pI:V:A"
}

gtk_dialog_set_modal :: !Pointer !Bool !.a -> .a
gtk_dialog_set_modal dialog setting env = code {
	ccall gtk_dialog_set_modal "pI:V:A"
}

gtk_entry_get_text :: !Pointer !.a -> (!String, !.a)
gtk_entry_get_text entry env
	# (ptr,env) = get entry env
	= (derefString ptr, env)
where
	get :: !Pointer !.a -> (!Pointer, !.a)
	get _ _ = code {
		ccall gtk_entry_get_text "p:p:A"
	}

gtk_entry_new :: !.a -> (!Pointer, !.a)
gtk_entry_new env = code {
	ccall gtk_entry_new ":p:A"
}

gtk_entry_set_completion :: !Pointer !Pointer !.a -> .a
gtk_entry_set_completion entry completion env = code {
	ccall gtk_entry_set_completion "pp:V:A"
}

gtk_entry_set_text :: !Pointer !String !.a -> .a
gtk_entry_set_text entry text env = set entry (packString text) env
where
	set :: !Pointer !String !.a -> .a
	set _ _ _ = code {
		ccall gtk_entry_set_text "ps:V:A"
	}

gtk_entry_completion_new :: !.a -> (!Pointer, !.a)
gtk_entry_completion_new env = code {
	ccall gtk_entry_completion_new ":p:A"
}

gtk_entry_completion_set_inline_completion :: !Pointer !Bool !.a -> .a
gtk_entry_completion_set_inline_completion completion setting env = code {
	ccall gtk_entry_completion_set_inline_completion "pI:V:A"
}

gtk_entry_completion_set_inline_selection :: !Pointer !Bool !.a -> .a
gtk_entry_completion_set_inline_selection completion setting env = code {
	ccall gtk_entry_completion_set_inline_selection "pI:V:A"
}

gtk_entry_completion_set_model :: !Pointer !Pointer !.a -> .a
gtk_entry_completion_set_model completion model env = code {
	ccall gtk_entry_completion_set_model "pp:V:A"
}

gtk_entry_completion_set_text_column :: !Pointer !Int !.a -> .a
gtk_entry_completion_set_text_column completion col env = code {
	ccall gtk_entry_completion_set_text_column "pI:V:A"
}

gtk_events_pending :: !.a -> (!Bool, !.a)
gtk_events_pending _ = code {
	ccall gtk_events_pending ":I:A"
}

gtk_file_chooser_add_filter :: !Pointer !Pointer !.a -> .a
gtk_file_chooser_add_filter chooser filter env = code {
	ccall gtk_file_chooser_add_filter "pp:V:A"
}

gtk_file_chooser_dialog_new :: !(Maybe String) !Pointer !Int ![(String,Int)] !.a -> (!Pointer, !.a)
gtk_file_chooser_dialog_new (Just title) parent action [(button,response)] env =
	new (packString title) parent action (packString button) response 0 env
where
	new :: !String !Pointer !Int !String !Int !Pointer !.a -> (!Pointer, !.a)
	new _ _ _ _ _ _ _ = code {
		ccall gtk_file_chooser_dialog_new "spIsIp:p:A"
	}
gtk_file_chooser_dialog_new (Just title) parent action [(b1,r1),(b2,r2)] env =
	new (packString title) parent action (packString b1) r1 (packString b2) r2 0 env
where
	new :: !String !Pointer !Int !String !Int !String !Int !Pointer !.a -> (!Pointer, !.a)
	new _ _ _ _ _ _ _ _ _ = code {
		ccall gtk_file_chooser_dialog_new "spIsIsIp:p:A"
	}
gtk_file_chooser_dialog_new Nothing parent action [(button,response)] env =
	new 0 parent action (packString button) response 0 env
where
	new :: !Pointer !Pointer !Int !String !Int !Pointer !.a -> (!Pointer, !.a)
	new _ _ _ _ _ _ _ = code {
		ccall gtk_file_chooser_dialog_new "ppIsIp:p:A"
	}
gtk_file_chooser_dialog_new Nothing parent action [(b1,r1),(b2,r2)] env =
	new 0 parent action (packString b1) r1 (packString b2) r2 0 env
where
	new :: !Pointer !Pointer !Int !String !Int !String !Int !Pointer !.a -> (!Pointer, !.a)
	new _ _ _ _ _ _ _ _ _ = code {
		ccall gtk_file_chooser_dialog_new "ppIsIsIp:p:A"
	}
gtk_file_chooser_dialog_new _ _ _ buttons env =
	trace_n
		("gtk_file_chooser_dialog_new: "+++toString (length buttons)+++" buttons not supported")
		(0, env)

gtk_file_chooser_get_filename :: !Pointer !.a -> (!Maybe String, !.a)
gtk_file_chooser_get_filename chooser env
	# (filename,env) = get chooser env
	| filename == 0 = (Nothing, env)
	# (filename_string,filename) = readP derefString filename
	# env = g_free filename env
	= (Just filename_string, env)
where
	get :: !Pointer !.a -> (!Pointer, !.a)
	get _ _ = code {
		ccall gtk_file_chooser_get_filename "p:p:A"
	}

gtk_file_filter_new :: !.a -> (!Pointer, !.a)
gtk_file_filter_new env = code {
	ccall gtk_file_filter_new ":p:A"
}

gtk_file_filter_add_pattern :: !Pointer !String !.a -> .a
gtk_file_filter_add_pattern filter pattern env = add filter (packString pattern) env
where
	add :: !Pointer !String !.a -> .a
	add _ _ _ = code {
		ccall gtk_file_filter_add_pattern "ps:V:A"
	}

gtk_frame_new :: !(Maybe String) !.a -> (!Pointer, !.a)
gtk_frame_new Nothing env = new 0 env
where
	new :: !Int !.a -> (!Pointer, !.a)
	new _ _ = code {
		ccall gtk_frame_new "p:p:A"
	}
gtk_frame_new (Just label) env = new label env
where
	new :: !String !.a -> (!Pointer, !.a)
	new _ _ = code {
		ccall gtk_frame_new "s:p:A"
	}

gtk_frame_set_label_align :: !Pointer !Real !Real !.a -> .a
gtk_frame_set_label_align frame xalign yalign env = code {
	ccall gtk_frame_set_label_align "prr:V:A"
}

gtk_grid_attach :: !Pointer !Pointer !Int !Int !Int !Int !.a -> .a
gtk_grid_attach grid child left top width height env = code {
	ccall gtk_grid_attach "ppIIII:V:A"
}

gtk_grid_new :: !.a -> (!Pointer, !.a)
gtk_grid_new env = code {
	ccall gtk_grid_new ":p:A"
}

gtk_init :: !.a -> .a
gtk_init env = init 0 0 env
where
	init :: !Pointer !Pointer !.a -> .a
	init argc argv env = code {
		ccall gtk_init "pp:V:A"
	}

gtk_label_new :: !.a -> (!Pointer, !.a)
gtk_label_new env = new 0 env
where
	new :: !Pointer !.a -> (!Pointer, !.a)
	new _ _ = code {
		ccall gtk_label_new "p:p:A"
	}

gtk_label_set_markup :: !Pointer !String !.a -> .a
gtk_label_set_markup label text env = set label (packString text) env
where
	set :: !Pointer !String !.a -> .a
	set _ _ _ = code {
		ccall gtk_label_set_markup "ps:V:A"
	}

gtk_list_store_append :: !Pointer -> .{#Int}
gtk_list_store_append store
	# iter = createArray 4 0 // size of GtkTreeIter
	# r = append store (get_array_pointer iter) 0
	| r <> 0
		= abort "internal error in gtk_list_store_append\n"
		= iter
where
	append :: !Pointer !Pointer !a -> a
	append _ _ _ = code {
		ccall gtk_list_store_append "pp:V:A"
	}

gtk_list_store_clear :: !Pointer !.a -> .a
gtk_list_store_clear store env = code {
	ccall gtk_list_store_clear "Gp:V:A"
}

gtk_list_store_newv :: !{#Int} !.a -> (!Pointer, !.a)
gtk_list_store_newv types env = newv (size types) (get_array_pointer types) env
where
	newv :: !Int !Pointer !.a -> (!Pointer, !.a)
	newv _ _ _ = code {
		ccall gtk_list_store_newv "Ip:p:A"
	}

gtk_list_store_set_bool :: !Pointer !.{#Int} !Int !Bool !.a -> .a
gtk_list_store_set_bool store iter col val env =
	set store (get_array_pointer iter) col val -1 env
where
	set :: !Pointer !Pointer !Int !Bool !Int !.a -> .a
	set _ _ _ _ _ _ = code {
		ccall gtk_list_store_set "GppIII:V:A"
	}

gtk_list_store_set_char :: !Pointer !.{#Int} !Int !Char !.a -> .a
gtk_list_store_set_char store iter col val env =
	set store (get_array_pointer iter) col val -1 env
where
	set :: !Pointer !Pointer !Int !Char !Int !.a -> .a
	set _ _ _ _ _ _ = code {
		ccall gtk_list_store_set "GppIII:V:A"
	}

gtk_list_store_set_int :: !Pointer !.{#Int} !Int !Int !.a -> .a
gtk_list_store_set_int store iter col val env =
	set store (get_array_pointer iter) col val -1 env
where
	set :: !Pointer !Pointer !Int !Int !Int !.a -> .a
	set _ _ _ _ _ _ = code {
		ccall gtk_list_store_set "GppIII:V:A"
	}

gtk_list_store_set_real :: !Pointer !.{#Int} !Int !Real !.a -> .a
gtk_list_store_set_real store iter col val env =
	set store (get_array_pointer iter) col val -1 env
where
	set :: !Pointer !Pointer !Int !Real !Int !.a -> .a
	set _ _ _ _ _ _ = code {
		ccall gtk_list_store_set "GppIRI:V:A"
	}

gtk_list_store_set_string :: !Pointer !.{#Int} !Int !String !.a -> .a
gtk_list_store_set_string store iter col val env =
	set store (get_array_pointer iter) col (packString val) -1 env
where
	set :: !Pointer !Pointer !Int !String !Int !.a -> .a
	set _ _ _ _ _ _ = code {
		ccall gtk_list_store_set "GppIsI:V:A"
	}

gtk_list_store_swap :: !Pointer !{#Int} !{#Int} !.a -> .a
gtk_list_store_swap store a b env = swap store (get_array_pointer a) (get_array_pointer b) env
where
	swap :: !Pointer !Pointer !Pointer !.a -> .a
	swap _ _ _ _ = code {
		ccall gtk_list_store_swap "Gppp:V:A"
	}

gtk_main_iteration :: !.a -> (!Bool, !.a)
gtk_main_iteration env = code {
	ccall gtk_main_iteration "G:I:A"
}

gtk_main_quit :: !.a -> .a
gtk_main_quit env = code {
	ccall gtk_main_quit ":V:A"
}

gtk_menu_bar_new :: !.a -> (!Pointer, !.a)
gtk_menu_bar_new env = code {
	ccall gtk_menu_bar_new ":p:A"
}

gtk_menu_item_new :: !.a -> (!Pointer, !.a)
gtk_menu_item_new env = code {
	ccall gtk_menu_item_new ":p:A"
}

gtk_menu_item_set_label :: !Pointer !String !.a -> .a
gtk_menu_item_set_label item label env = set item (packString label) env
where
	set :: !Pointer !String !.a -> .a
	set _ _ _ = code {
		ccall gtk_menu_item_set_label "ps:V:A"
	}

gtk_menu_item_set_use_underline :: !Pointer !Bool !.a -> .a
gtk_menu_item_set_use_underline item setting env = code {
	ccall gtk_menu_item_set_use_underline "pI:V:A"
}

gtk_menu_item_set_submenu :: !Pointer !Pointer !.a -> .a
gtk_menu_item_set_submenu item menu env = code {
	ccall gtk_menu_item_set_submenu "pp:V:A"
}

gtk_menu_new :: !.a -> (!Pointer, !.a)
gtk_menu_new env = code {
	ccall gtk_menu_new ":p:A"
}

gtk_menu_shell_append :: !Pointer !Pointer !.a -> .a
gtk_menu_shell_append shell item env = code {
	ccall gtk_menu_shell_append "pp:V:A"
}

gtk_message_dialog_new_with_markup :: !Pointer !Int !Int !Int !String !.a -> (!Pointer, !.a)
gtk_message_dialog_new_with_markup window flags type buttons text env =
	new window flags type buttons (packString text) env
where
	new :: !Pointer !Int !Int !Int !String !.a -> (!Pointer, !.a)
	new _ _ _ _ _ _ = code {
		ccall gtk_message_dialog_new "pIIIs:p:A"
	}

gtk_orientable_set_orientation :: !Pointer !Bool !.a -> .a
gtk_orientable_set_orientation orientable orientation env = code {
	ccall gtk_orientable_set_orientation "pI:V:A"
}

gtk_paned_new :: !Bool !.a -> (!Pointer, !.a)
gtk_paned_new vertical env = code {
	ccall gtk_paned_new "I:p:A"
}

gtk_paned_pack1 :: !Pointer !Pointer !Bool !Bool !.a -> .a
gtk_paned_pack1 paned child resize shrink env = code {
	ccall gtk_paned_pack1 "ppII:V:A"
}

gtk_paned_pack2 :: !Pointer !Pointer !Bool !Bool !.a -> .a
gtk_paned_pack2 paned child resize shrink env = code {
	ccall gtk_paned_pack2 "ppII:V:A"
}

gtk_paned_set_wide_handle :: !Pointer !Bool !.a -> .a
gtk_paned_set_wide_handle paned setting env = code {
	ccall gtk_paned_set_wide_handle "pI:V:A"
}

gtk_scrolled_window_new :: !Pointer !Pointer !.a -> (!Pointer, !.a)
gtk_scrolled_window_new hadjust vadjust env = code {
	ccall gtk_scrolled_window_new "pp:p:A"
}

gtk_scrolled_window_set_policy :: !Pointer !Int !Int !.a -> .a
gtk_scrolled_window_set_policy window hpolicy vpolicy env = code {
	ccall gtk_scrolled_window_set_policy "pII:V:A"
}

gtk_search_entry_new :: !.a -> (!Pointer, !.a)
gtk_search_entry_new env = code {
	ccall gtk_search_entry_new ":p:A"
}

gtk_separator_menu_item_new :: !.a -> (!Pointer, !.a)
gtk_separator_menu_item_new env = code {
	ccall gtk_separator_menu_item_new ":p:A"
}

gtk_separator_new :: !Bool !.a -> (!Pointer, !.a)
gtk_separator_new vertical env = code {
	ccall gtk_separator_new "I:p:A"
}

gtk_spinner_new :: !.a -> (!Pointer, !.a)
gtk_spinner_new env = code {
	ccall gtk_spinner_new ":p:A"
}

gtk_spinner_start :: !Pointer !.a -> .a
gtk_spinner_start spinner env = code {
	ccall gtk_spinner_start "p:V:A"
}

gtk_spinner_stop :: !Pointer !.a -> .a
gtk_spinner_stop spinner env = code {
	ccall gtk_spinner_stop "p:V:A"
}

gtk_style_context_add_class :: !Pointer !String !.a -> .a
gtk_style_context_add_class context cls env = add context (packString cls) env
where
	add :: !Pointer !String !.a -> .a
	add _ _ _ = code {
		ccall gtk_style_context_add_class "ps:V:A"
	}

gtk_style_context_add_provider :: !Pointer !Pointer !Int !.a -> .a
gtk_style_context_add_provider context provider priority env = code {
	ccall gtk_style_context_add_provider "ppI:V:A"
}

gtk_style_context_add_provider_for_screen :: !Pointer !Pointer !Int !.a -> .a
gtk_style_context_add_provider_for_screen context provider priority env = code {
	ccall gtk_style_context_add_provider_for_screen "ppI:V:A"
}

gtk_style_context_remove_class :: !Pointer !String !.a -> .a
gtk_style_context_remove_class context cls env = remove context (packString cls) env
where
	remove :: !Pointer !String !.a -> .a
	remove _ _ _ = code {
		ccall gtk_style_context_remove_class "ps:V:A"
	}

gtk_text_buffer_delete :: !Pointer !{#Int} !{#Int} !.a -> .a
gtk_text_buffer_delete buffer start end env =
	delete buffer (get_array_pointer start) (get_array_pointer end) env
where
	delete :: !Pointer !Pointer !Pointer !.a -> .a
	delete _ _ _ _ = code {
		ccall gtk_text_buffer_delete "ppp:V:A"
	}

gtk_text_buffer_get_start_iter :: !Pointer !.a -> (!{#Int}, !.a)
gtk_text_buffer_get_start_iter buffer env
	# iter = createArray (IF_INT_64_OR_32 10 14) 0 /* large enough to hold GtkTextIter */
	= (iter, get buffer (get_array_pointer iter) env)
where
	get :: !Pointer !Pointer !.a -> .a
	get _ _ _ = code {
		ccall gtk_text_buffer_get_start_iter "pp:V:A"
	}

gtk_text_buffer_get_end_iter :: !Pointer !.a -> (!{#Int}, !.a)
gtk_text_buffer_get_end_iter buffer env
	# iter = createArray (IF_INT_64_OR_32 10 14) 0 /* large enough to hold GtkTextIter */
	= (iter, get buffer (get_array_pointer iter) env)
where
	get :: !Pointer !Pointer !.a -> .a
	get _ _ _ = code {
		ccall gtk_text_buffer_get_end_iter "pp:V:A"
	}

gtk_text_buffer_insert_at_cursor :: !Pointer !String !Int !.a -> .a
gtk_text_buffer_insert_at_cursor buffer string len env = code {
	ccall gtk_text_buffer_insert_at_cursor "psI:V:A"
}

gtk_text_buffer_insert_markup :: !Pointer !{#Int} !String !.a -> .a
gtk_text_buffer_insert_markup buffer iter string env =
	insert buffer (get_array_pointer iter) (packString string) (size string) env
where
	insert :: !Pointer !Int !String !Int !.a -> .a
	insert _ _ _ _ _ = code {
		ccall gtk_text_buffer_insert_markup "pIsI:V:A"
	}

gtk_text_buffer_set_text :: !Pointer !String !Int !.a -> .a
gtk_text_buffer_set_text buffer string len env = code {
	ccall gtk_text_buffer_set_text "psI:V:A"
}

gtk_text_view_new :: !.a -> (!Pointer, !.a)
gtk_text_view_new env = code {
	ccall gtk_text_view_new ":p:A"
}

gtk_text_view_get_buffer :: !Pointer -> Pointer
gtk_text_view_get_buffer text_view = code {
	ccall gtk_text_view_get_buffer "p:p"
}

gtk_text_view_set_editable :: !Pointer !Bool !.a -> .a
gtk_text_view_set_editable text_view setting env = code {
	ccall gtk_text_view_set_editable "pI:V:A"
}

gtk_text_view_set_pixels_above_lines :: !Pointer !Int !.a -> .a
gtk_text_view_set_pixels_above_lines text_view px env = code {
	ccall gtk_text_view_set_pixels_above_lines "pI:V:A"
}

gtk_text_view_set_pixels_below_lines :: !Pointer !Int !.a -> .a
gtk_text_view_set_pixels_below_lines text_view px env = code {
	ccall gtk_text_view_set_pixels_below_lines "pI:V:A"
}

gtk_text_view_set_pixels_inside_wrap :: !Pointer !Int !.a -> .a
gtk_text_view_set_pixels_inside_wrap text_view px env = code {
	ccall gtk_text_view_set_pixels_inside_wrap "pI:V:A"
}

gtk_text_view_set_wrap_mode :: !Pointer !Int !.a -> .a
gtk_text_view_set_wrap_mode text_view mode env = code {
	ccall gtk_text_view_set_wrap_mode "pI:V:A"
}

gtk_tree_model_get_iter_from_string :: !Pointer !String -> (!Bool, !{#Int})
gtk_tree_model_get_iter_from_string model path
	# iter = createArray 4 0 // size of GtkTreeIter
	# ok = get model (get_array_pointer iter) (packString path)
	= (ok, iter)
where
	get :: !Pointer !Pointer !String -> Bool
	get _ _ _ = code {
		ccall gtk_tree_model_get_iter_from_string "pps:I"
	}

gtk_tree_model_get_string_from_iter :: !Pointer !{#Int} -> String
gtk_tree_model_get_string_from_iter model iter
	# path = get model (get_array_pointer iter)
	# (path_string,path) = readP derefString path
	= g_free path path_string
where
	get :: !Pointer !Pointer -> Pointer
	get _ _ = code {
		ccall gtk_tree_model_get_string_from_iter "pp:p"
	}

gtk_tree_selection_get_selected :: !Pointer !.a -> (!(!Bool, !{#Int}), !.a)
gtk_tree_selection_get_selected sel env
	# iter = createArray 4 0 // size of GtkTreeIter
	# (r,env) = get sel 0 (get_array_pointer iter) env
	= ((r, iter), env)
where
	get :: !Pointer !Pointer !Pointer !.a -> (!Bool, !.a)
	get _ _ _ _ = code {
		ccall gtk_tree_selection_get_selected "ppp:I:A"
	}

gtk_tree_selection_select_iter :: !Pointer !{#Int} !.a -> .a
gtk_tree_selection_select_iter sel iter env = select sel (get_array_pointer iter) env
where
	select :: !Pointer !Pointer !.a -> .a
	select _ _ _ = code {
		ccall gtk_tree_selection_select_iter "Gpp:V:A"
	}

gtk_tree_view_column_add_attribute :: !Pointer !Pointer !String !Int !.a -> .a
gtk_tree_view_column_add_attribute tree_column renderer attr column env =
	add tree_column renderer (packString attr) column env
where
	add :: !Pointer !Pointer !String !Int !.a -> .a
	add _ _ _ _ _ = code {
		ccall gtk_tree_view_column_add_attribute "ppsI:V:A"
	}

gtk_tree_view_column_new :: !.a -> (!Pointer, !.a)
gtk_tree_view_column_new env = code {
	ccall gtk_tree_view_column_new ":p:A"
}

gtk_tree_view_column_pack_start :: !Pointer !Pointer !Bool !.a -> .a
gtk_tree_view_column_pack_start column renderer expand env = code {
	ccall gtk_tree_view_column_pack_start "ppI:V:A"
}

gtk_tree_view_column_set_sizing :: !Pointer !Int !.a -> .a
gtk_tree_view_column_set_sizing column sizing env = code {
	ccall gtk_tree_view_column_set_sizing "pI:V:A"
}

gtk_tree_view_column_set_sort_column_id :: !Pointer !Int !.a -> .a
gtk_tree_view_column_set_sort_column_id column id env = code {
	ccall gtk_tree_view_column_set_sort_column_id "pI:V:A"
}

gtk_tree_view_column_set_title :: !Pointer !String !.a -> .a
gtk_tree_view_column_set_title column title env = set column (packString title) env
where
	set :: !Pointer !String !.a -> .a
	set _ _ _ = code {
		ccall gtk_tree_view_column_set_title "ps:V:A"
	}

gtk_tree_view_append_column :: !Pointer !Pointer !.a -> .a
gtk_tree_view_append_column tree column env = code {
	ccall gtk_tree_view_append_column "pp:V:A"
}

gtk_tree_view_get_model :: !Pointer -> Pointer
gtk_tree_view_get_model tree = code {
	ccall gtk_tree_view_get_model "p:p"
}

gtk_tree_view_get_selection :: !Pointer -> Pointer
gtk_tree_view_get_selection tree = code {
	ccall gtk_tree_view_get_selection "p:p"
}

gtk_tree_view_new_with_model :: !Pointer !.a -> (!Pointer, !.a)
gtk_tree_view_new_with_model model env = code {
	ccall gtk_tree_view_new_with_model "p:p:A"
}

gtk_widget_add_accelerator :: !Pointer !String !Pointer !Int !Int !Int !.a -> .a
gtk_widget_add_accelerator widget signal accel_group key mask flags env =
	add widget (packString signal) accel_group key mask flags env
where
	add :: !Pointer !String !Pointer !Int !Int !Int !.a -> .a
	add _ _ _ _ _ _ _ = code {
		ccall gtk_widget_add_accelerator "pspIII:V:A"
	}

gtk_widget_destroy :: !Pointer !.a -> .a
gtk_widget_destroy widget env = code {
	ccall gtk_widget_destroy "p:V:A"
}

gtk_widget_get_screen :: !Pointer !.a -> (!Pointer, !.a)
gtk_widget_get_screen widget env = code {
	ccall gtk_widget_get_screen "p:p:A"
}

gtk_widget_get_style_context :: !Pointer !.a -> (!Pointer, !.a)
gtk_widget_get_style_context widget env = code {
	ccall gtk_widget_get_style_context "p:p:A"
}

gtk_widget_grab_focus :: !Pointer !.a -> .a
gtk_widget_grab_focus widget env = code {
	ccall gtk_widget_grab_focus "p:V:A"
}

gtk_widget_hide :: !Pointer !.a -> .a
gtk_widget_hide widget env = code {
	ccall gtk_widget_hide "p:V:A"
}

gtk_widget_is_visible :: !Pointer !.a -> (!Bool, !.a)
gtk_widget_is_visible widget env = code {
	ccall gtk_widget_is_visible "p:I:A"
}

gtk_widget_set_halign :: !Pointer !Int !.a -> .a
gtk_widget_set_halign widget align env = code {
	ccall gtk_widget_set_halign "pI:V:A"
}

gtk_widget_set_hexpand :: !Pointer !Bool !.a -> .a
gtk_widget_set_hexpand widget align env = code {
	ccall gtk_widget_set_hexpand "pI:V:A"
}

gtk_widget_set_margin_bottom :: !Pointer !Int !.a -> .a
gtk_widget_set_margin_bottom widget padding env = code {
	ccall gtk_widget_set_margin_bottom "pI:V:A"
}

gtk_widget_set_margin_left :: !Pointer !Int !.a -> .a
gtk_widget_set_margin_left widget padding env = code {
	ccall gtk_widget_set_margin_left "pI:V:A"
}

gtk_widget_set_margin_right :: !Pointer !Int !.a -> .a
gtk_widget_set_margin_right widget padding env = code {
	ccall gtk_widget_set_margin_right "pI:V:A"
}

gtk_widget_set_margin_top :: !Pointer !Int !.a -> .a
gtk_widget_set_margin_top widget padding env = code {
	ccall gtk_widget_set_margin_top "pI:V:A"
}

gtk_widget_set_sensitive :: !Pointer !Bool !.a -> .a
gtk_widget_set_sensitive widget setting env = code {
	ccall gtk_widget_set_sensitive "pI:V:A"
}

gtk_widget_set_size_request :: !Pointer !Int !Int !.a -> .a
gtk_widget_set_size_request widget hsize vsize env = code {
	ccall gtk_widget_set_size_request "pII:V:A"
}

gtk_widget_set_valign :: !Pointer !Int !.a -> .a
gtk_widget_set_valign widget align env = code {
	ccall gtk_widget_set_valign "pI:V:A"
}

gtk_widget_set_vexpand :: !Pointer !Bool !.a -> .a
gtk_widget_set_vexpand widget align env = code {
	ccall gtk_widget_set_vexpand "pI:V:A"
}

gtk_widget_show :: !Pointer !.a -> .a
gtk_widget_show widget env = code {
	ccall gtk_widget_show "p:V:A"
}

gtk_window_add_accel_group :: !Pointer !Pointer !.a -> .a
gtk_window_add_accel_group window group env = code {
	ccall gtk_window_add_accel_group "pp:V:A"
}

gtk_window_new :: !Bool !.a -> (!Pointer, !.a)
gtk_window_new is_popup env = code {
	ccall gtk_window_new "I:p:A"
}

gtk_window_set_title :: !Pointer !String !.a -> .a
gtk_window_set_title window title env = set window (packString title) env
where
	set :: !Pointer !String !.a -> .a
	set _ _ _ = code {
		ccall gtk_window_set_title "ps:V:A"
	}

gtk_window_set_transient_for :: !Pointer !Pointer !.a -> .a
gtk_window_set_transient_for window parent env = code {
	ccall gtk_window_set_transient_for "pp:V:A"
}

get_array_pointer :: !{#Int} -> Pointer
get_array_pointer arr = get arr + IF_INT_64_OR_32 24 12
where
	get :: !{#Int} -> Pointer
	get _ = code {
		push_a_b 0
		pop_a 1
	}