mollusk/eumandy
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
eumandy/eugtk/examples/GtkEngine.e
mollusk c0b98b619e added eugtk examples
2016-11-25 00:33:18 -07:00

9649 lines
278 KiB
Plaintext
Raw Blame History

-------------
namespace gtk
-------------
------------------------------------------------------------------------
-- This library is free software; you can redistribute it
-- and/or modify it under the terms of the GNU Lesser General
-- Public License as published by the Free Software Foundation;
-- either version 2 of the License, or (at your option) any later
-- version.
-- This library is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-- See the GNU Lesser General Public License for more details.
-- You should have received a copy of the GNU Lesser General Public
-- License along with this library; if not, write to the Free Software
-- Foundation, Inc., 59 Temple Pl, Suite 330, Boston, MA 02111-1307 USA
------------------------------------------------------------------------
export constant
version = "4.12.0",
release = "Sept 1, 2016",
copyright = " © 2016 by Irv Mullins"
public object ACCEL_FONT = "italic 10" -- affects accels in menus;
public integer BTN_ICON_SIZE = 20 -- pixels;
public integer BTN_TEXT_SIZE = 12
public integer BTN_SHOW_IMG = 1
public include GtkEnums.e
-- GtkEnums includes most of Eu std libraries as public,
-- making them available to your eu programs without
-- having to specifically include them.
if not equal(gtk:version,enums:version) then -- these 2 must be in sync!
crash("Version mismatch: GtkEnums should be version %s",{version})
end if
-- std/math, std/locale, std/datetime, etc. aren't made
-- public, because that would cause too many conflicts,
-- requiring you to use namespaces everywhere,
-- but we do need them here;
include std/datetime.e
include std/locale.e
include std/math.e
include std/net/dns.e
include std/utils.e
include std/net/http.e
include std/pipeio.e as pipe
public constant -- 'shorthand' identifiers to save space in method prototypes;
P = C_POINTER, -- any valid pointer
B = C_BYTE, -- 8 bits (boolean)
I = C_INT, -- 32 (integer)
S = E_ATOM, -- 64 (string)
D = C_DOUBLE, -- 64 (double)
F = C_FLOAT, -- 32 (float)
A = E_INTEGER, -- 32/64 (glist ptr)
X = E_OBJECT, -- 32/64 (array of pointers)
V = E_SEQUENCE -- 32/64 (pointer to array of strings)
-- hopefully, the above are compatible with both 32 and 64-bit architectures
export object LIBS -- a single lib in UNIX, a sequence of dll's for Windows;
ifdef OSX then -- thanks to Pete Eberlein for testing with OSX!
LIBS = {open_dll("/opt/local/lib/libgtk-3.dylib" )}
elsifdef UNIX then -- Linux, BSD, etc.
LIBS = {open_dll("libgtk-3.so.0" )}
elsifdef WINDOWS then
object path = "C:/Program Files/GTK3-Runtime Win64/bin/" -- 3.18.6 is the vers. tested.
LIBS = dir(path & "*.dll") -- get a list of all .dll's in that folder;
LIBS = vslice(LIBS,1) -- retain only the filenames;
if atom(LIBS) then -- none found;
crash("\nFATAL ERROR:\n************ Cannot find GTK runtime libraries (.dlls)\n")
end if
atom x
for i = 1 to length(LIBS) do -- load each;
x = open_dll(LIBS[i])
if x = 0 then
display("Error loading []",{LIBS[i]})
else
LIBS[i] = x -- append this lib to list of libs;
end if
end for
end ifdef -- PLATFORMS;
if not object(LIBS) then -- no point in continuing;
crash("Required libraries not found!")
end if
constant cmd = pad_tail(command_line(),4,"")
if not gtk_func("gtk_init_check",{P,P},{0,0}) then -- initialize the GTK library;
crash("GTK Library error - cannot init GTK!")
else -- success!
gtk_proc("g_set_prgname",{S}," " & filename(cmd[2])) -- set default pgm name;
gtk_proc("g_type_init",{}) -- initialize normal GTK types;
end if
public constant -- two special types must be initialized at run-time;
gPIX = gtk_func("gdk_pixbuf_get_type"),
gCOMBO = gtk_func("gtk_combo_box_get_type")
-------------------------------------------------------------
-- Obtain a lot of sometimes useful system info;
-------------------------------------------------------------
include euphoria/info.e
constant os_info = os:uname()
export object
major_version = gtk_func("gtk_get_major_version"),
minor_version = gtk_func("gtk_get_minor_version"),
micro_version = gtk_func("gtk_get_micro_version"),
user_name = gtk_str_func("g_get_user_name"),
real_name = gtk_str_func("g_get_real_name"),
curr_dir = current_dir(),
home_dir = gtk_str_func("g_get_home_dir"),
temp_dir = gtk_str_func("g_get_tmp_dir"),
data_dir = gtk_str_func("g_get_user_data_dir"),
conf_dir = gtk_str_func("g_get_user_config_dir"),
runt_dir = gtk_str_func("g_get_user_runtime_dir"),
app_name = gtk_str_func("g_get_application_name"),
prg_name = gtk_str_func("g_get_prgname"),
lang_ = gtk_func("gtk_get_default_language"),
def_lang = gtk_str_func("pango_language_to_string",{P},{lang_}),
login = pathname(cmd[2]),
os_pid = os:get_pid(), -- process id: e.g:1234
os_name = os_info[1], -- e.g: Linux
os_distro = os_info[2], -- e.g: Mint17
os_version = os_info[3], -- e.g: 3.13.0-24-generic
os_compiled = os_info[4],
os_arch = os_info[5], -- e.g: AMD64
os_inc = getenv("EUINC"),
os_dir = getenv("EUDIR"),
os_path = getenv("PATH"),
os_shell = getenv("SHELL"),
os_term = getenv("TERM"),
eu_platform = platform_name(),
host_name = gtk_str_func("g_get_host_name"),
host_addr = "127.0.0.1"
ifdef BITS64 then
constant eu_arch_bits = "64"
elsedef
constant eu_arch_bits = "32"
end ifdef
if atom(os_term) then os_term = "none" end if
ifdef WINDOWS then
user_name = getenv("USERNAME")
real_name = getenv("USERNAME")
home_dir = getenv("HOMEPATH")
temp_dir = getenv("TEMP")
os_name = getenv("OS")
os_term = getenv("SESSIONNAME")
os_compiled = getenv("PROCESSOR_IDENTIFIER")
end ifdef
-- following added because Windows misbehaves in the ifdef above :(
if atom(os_term) then os_term = getenv("SESSIONNAME") end if
if atom(os_shell) then os_shell = getenv("ComSpec") end if
if atom(os_arch) then os_arch = getenv("PROCESSOR_ARCHITECTURE") end if
export object info = { -- above system info in key/value form, sometimes this is useful;
"version=" & version,
"release=" & release,
"copyright=" & copyright,
"major=" & to_string(major_version),
"minor=" & to_string(minor_version),
"micro=" & to_string(micro_version),
"user_name=" & user_name,
"real_name=" & real_name,
"host_name=" & host_name,
"host_addr=" & host_addr,
"home_dir=" & home_dir,
"temp_dir=" & temp_dir,
"curr_dir=" & curr_dir,
"data_dir=" & data_dir,
"conf_dir=" & conf_dir,
"runt_dir=" & runt_dir,
"app_name=" & app_name,
"prg_name=" & prg_name,
"os_pid=" & to_string(os:get_pid()),
"os_name=" & os_info[1],
"os_distro=" & os_info[2],
"os_vers=" & os_info[3],
"os_comp=" & os_compiled,
"os_arch=" & os_arch,
"os_term=" & os_term,
"os_shell=" & os_shell,
"os_inc=" & os_inc,
"os_dir=" & os_dir,
"os_path=" & os_path,
"def_lang=" & def_lang,
"eu_version=" & version_string_short(),
"eu_revision=" & to_string(version_revision()),
"eu_platform=" & eu_platform,
"eu_arch_bits=" & eu_arch_bits,
"eu_date=" & version_date(),
"today=" & datetime:format(datetime:now(),"%A %B %d, %Y"),
"start_time=" & datetime:format(datetime:now(),"%H:%M:%S"),
"CMD1=" & cmd[1],
"CMD2=" & canonical_path(cmd[2]),
"CMD3=" & pathname(canonical_path(cmd[2])),
$}
---------------------------
export function networked()
---------------------------
atom m = gtk_func("g_network_monitor_get_default")
return gtk_func("g_network_monitor_get_network_available",{P},{m})
end function
-----------------------------------
export function inet_connected() -- ping msftncsi
-----------------------------------
atom err = allocate(8) err = 0
atom x = gtk_func("g_network_address_parse_uri",{P,I,P},
{allocate_string("www.msftncsi.com"),80,err})
if x > 0 then return gtk_str_func("g_socket_connectable_to_string",{P},{x})
else return x
end if
end function
--------------------------------
export function get_net_address()
--------------------------------
object results
object addr
ifdef UNIX then
sequence tmp = temp_file(,"MYIP-")
system_exec(sprintf(`ifconfig | grep "inet addr:" > %s`,{tmp}),2)
results = trim(read_file(tmp))
results = split(results," ")
delete_file(tmp)
for i = 1 to length(results) do
if match("inet addr:",results[i]) = 1 then
addr = split(results[i],':')
host_addr = addr[2]
info[11] = "host_addr=" & host_addr
return host_addr
end if
end for
end ifdef
return "127.0.0.1"
end function
---------------------------------------------------------
public procedure requires(sequence a, object msg="Error")
---------------------------------------------------------
-- an easy way to ensure that your program is using the
-- appropriate GTK version;
object s = split(a,'.')
if length(s) < 3 then s = append(s,"0") end if
s[1] = to_number(s[1])
s[2] = to_number(s[2])
s[3] = to_number(s[3])
object msg2 = gtk_str_func("gtk_check_version",{I,I,I},{s[1],s[2],s[3]})
if string(msg2) then
Warn(,msg,msg2,
text:format("Requires Gtk version []\nInstalled is Gtk [].[].[]",
{a,major_version,minor_version,micro_version}))
abort(1)
end if
end procedure
enum NAME,PARAMS,RETVAL,VECTOR,CLASS
---------------------------------------------------------
public function create(integer class,
object p1=0, object p2=0, object p3=0, object p4=0,
object p5=0, object p6=0, object p7=0, object p8=0)
---------------------------------------------------------
-- This function does the following:
-- 1. initializes the class if not already initialized,
-- 2. creates a new instance of the class (returning a handle to that instance)
-- 3. optionally sets one or more properties and/or connects the default signal.
---------------------------------------------------------------------------------------
if class = GtkStockList then -- GtkStock is not a real widget, but we fake it
return newStockList()-- also, stock items are deprecated as of 3.10+
end if -- so don't get in the habit of using them too much :)
if class = GtkColumn then return newColumn(p1) end if
if not initialized[class] then -- create a routine_id for each 'method' in class
init(class) -- but only do it if this is the first call to that class
end if
object method = lookup("new",vslice(widget[class],1),widget[class],0)
if method[VECTOR] = -1 then -- a 'new' method name was not found;
Error(,,widget[class][$],"not implemented in this GTK version!")
abort(class)
end if
object props = 0, dataitem = 0
if sequence(p1) and sequence(p1[1]) then -- a list of properties was provided.
props = p1 -- save until widget is created,
p1 = 0 -- then set them in one 'swell foop'
elsif string(p1) and match("=",p1) then -- properties were provided in string form,
props = keyvalues(p1,,,,"\t\n\r")-- break them up into key/value pairs,
p1 = 0 -- save for later;
dataitem = vlookup("data",props,1,2)
end if
atom handle = 0
object params = method[PARAMS]
object args = {p1,p2,p3,p4,p5,p6,p7,p8}
args = args[1..length(params)] -- discard un-needed args;
ifdef PARAMS then display(params) end ifdef -- debug;
for i = 1 to length(params) do -- ensure values match formal params;
switch params[i] do
case S then -- convert string to pointer to cstring;
if string(args[i]) then
args[i] = allocate_string(args[i])
end if
case B then -- convert "1", "TRUE", or "YES" to 1,
if string(args[i]) then
if args[i] = "1"
or upper(args[i]) = "TRUE"
or upper(args[i]) = "YES" then
args[i] = 1
else
args[i] = 0 -- anything else is 0;
end if
end if
end switch
end for
ifdef CREATE then -- debug;
display(decode_method("CREATE",class,method))
puts(1,"\tArgs: ") display(args,{2,5,10,78,"%d","%.2g",32,127,1,0})
ifdef METHOD then display(method) end ifdef
end ifdef
if method[RETVAL] > 0 then -- it's a GTK function (routine_id is positive);
handle = c_func(method[VECTOR],args)
end if
if method[RETVAL] < -1 then -- it's a Eu func (a negated routine_id)
handle = call_func(-method[VECTOR],args) -- convert to positive rid and call;
end if
if handle = 0 then -- failure :(
ifdef CREATE then
display("Create failed for class []",{widget[class][$]})
end ifdef
return handle
end if
object sig = 0, arg1 = 0 ,arg2 = 0
switch class do -- connect a default signal for some common controls;
case GtkButton then sig ="clicked" arg1 = p2 arg2 = p3
case GtkToolButton then sig ="clicked" arg1 = p3 arg2 = p4
case GtkRadioButton then sig ="toggled" arg1 = p3 arg2 = p4
case GtkRadioToolButton then sig = "toggled" arg1 = p3 arg2 = p4
case GtkRadioMenuItem then sig ="toggled" arg1 = p3 arg2 = p4
case GtkMenuItem then sig ="activate" arg1 = p2 arg2 = p3
case GtkCheckMenuItem then sig = "toggled" arg1 = p2 arg2 = p3
case GtkCellRendererToggle then sig = "toggled" arg1 = p1 arg2 = p2
case GtkFontButton then sig = "font-set" arg1 = p2 arg2 = p3
case GtkStatusIcon then sig = "activate" arg1 = p1 arg2 = p2
case GtkSwitch then sig = "notify::active" arg1 = p1 arg2 = p2
case GtkColorButton then sig = "color-set" arg1 = p2 arg2 = p3
case GtkCalendar then sig = "day-selected-double-click" arg1 = p2 arg2 = p3
case GtkComboBoxText, GtkComboBoxEntry then sig ="changed" arg1 = p1 arg2 = p2
case GtkCheckButton then sig ="toggled" arg1 = p2 arg2 = p3
case GtkToggleButton then sig ="toggled" arg1 = p2 arg2 = p3
case GtkToggleToolButton then sig ="toggled" arg1 = p2 arg2 = p3
end switch
if atom(arg2) and arg2 = 0 then arg2 = dataitem end if
connect(handle,sig,arg1,arg2) -- connect per above switch;
ifdef CREATE then -- debug;
display("\t[] => []\n",{widget[class][$],handle})
end ifdef
register(handle,class)
if class = GtkWindow then -- if not otherwise specified, use OpenEu logo;
atom err= allocate(8,1)
gtk_func("gtk_window_set_default_icon_from_file",{P,P},
{allocate_string(locate_file("./thumbnails/mongoose.png"),1),err})
end if
----------------------------------------------------------------------
-- set properties using the new key/val style;
----------------------------------------------------------------------
object p = 0, signal, name, v1, v2, v3, v4
if not atom(props) then
if handle > 0 then
for i = 1 to length(props) do
while length(props[i]) < 5 do
props[i] &= 0
end while
for n = 1 to 5 do
props[i][n] = numeric_test(props[i][n])
end for
end for
for i = 1 to length(props) do
name = props[i][1]
v1 = props[i][2]
v2 = props[i][3]
v3 = props[i][4]
v4 = props[i][5]
ifdef SET then
display("\nset []->[]",{widget[class][$],props[i]})
end ifdef
if match("sig.",name) = 1 then
signal = name[5..$]
connect(handle,signal,v1,dataitem)
elsif match("$",name) = 1 then
signal = name[2..$]
connect(handle,signal,v1,dataitem)
elsif match("data.",name) = 1 then
set(handle,"data",name[6..$],v1)
else
set(handle,name,v1,v2,v3,v4)
end if
end for
end if
end if
return handle -- a pointer to the newly created instance
end function
------------------------------------------------------------------------
public function set(object handle, sequence property,
object p1=0, object p2=0, object p3=0, object p4=0,
object p5=0, object p6=0, object p7=0, object p8=0)
------------------------------------------------------------------------
-- This routine sets a property or sequence of properties
-- for the given widget.
-- In order to work with Glade, widget names in string form
-- may be used, otherwise set() expects a handle.
-- Property is always a string, p1...p8 are optional parameters.
-- Any parameter expected but not supplied is set to null, excess
-- parameters are discarded.
------------------------------------------------------------------------
integer class=-1
object name = "unknown"
object result = 0
object allocated = {}
name = handle
ifdef SETX then display({name,property,p1,p2,p3,p4}) end ifdef
if string(handle) then handle = pointer(handle) end if
if handle = 0 then
printf(1,"Critical error\n" &
"Objects must have a unique name!\n%s [%d]",{name,handle})
return 0
end if
object prop = 0
if string(property) and match("=",property) > 0 then -- convert string props
property = keyvalues(property,,,,"\t\t\n") -- to key/val form;
end if
if sequence(property) -- new create format (key=value pairs);
and not string(property) then
for i = 1 to length(property) do
while length(property[i]) < 5 do
property[i] &= 0
end while
for n = 1 to 5 do
property[i][n] = numeric_test(property[i][n])
end for
end for
for i = 1 to length(property) do
prop = property[i] if prop[1][1]='$' then continue end if
while length(prop) < 8 do prop &= 0 end while
set(handle,prop[1],prop[2],prop[3],prop[4],prop[5],prop[6],prop[7],prop[8])
end for
return 0
end if
class = vlookup(handle,registry,1,2,-1) -- get widget's class;
if class = -1 then -- fail;
display("Set invalid handle [] []",{handle,prop})
end if
property = "set_" & lower(join(split(property,' '),'_')) -- conform;
object method = lookup_method(class,property)
ifdef METHOD then display(method) end ifdef
if atom(method) then
if not set_property(handle,property[5..$],numeric_test(p1)) then
Error(,,"Cannot set property",class_name(handle) & property)
end if
return 0
end if
if method[VECTOR] = -1 then
Warn(,,"Method not found",
sprintf("%s->%s",{class_name(handle),property}))
return 0
end if
-- method was found;
object params = method[PARAMS]
switch method[1] do -- make life easier for a common operation;
case "set_from_file" then p1 = canonical_path(p1)
end switch
object args = {handle,p1,p2,p3,p4,p5,p6,p7,p8}
ifdef PARAMS then
puts(1,"Params: ") display(params)
puts(1,"Args: ") display(args)
end ifdef
args = args[1..length(params)] -- match args to formal parameters;
for i = 2 to length(args) do
switch params[i] do
case A then -- array of strings;
if not atom(args[i]) then
args[i] = allocate_string_pointer_array(args[i])
allocated &= args[i]
end if
case S then -- string;
if atom(args[i]) then
args[i] = sprintf("%g",args[i])
end if
if string(args[i]) then
args[i] = allocate_string(args[i])
allocated &= args[i]
end if
case B then
if string(args[i]) then
if equal("TRUE",upper(args[i]))
or equal("YES",upper(args[i]))
or equal("1",args[i]) then
args[i] = 1
end if
if equal("FALSE",upper(args[i]))
or equal("NO",upper(args[i]))
or equal("0",args[i]) then
args[i] = 0
end if
end if
case I,D then
if string(args[i]) then
args[i] = to_number(args[i])
end if
-- apply patches for zero-based indexes;
switch method[1] do
case "add_attribute",
"set_active",
"set_text_column",
"set_pixbuf_column",
"set_tooltip_column",
"set_search_column",
"attribute_connect",
"reorder_child",
"page",
"remove_page",
"set_current_page",
"set_sort_column_id" then args[i]-=1
end switch
end switch
end for
ifdef SET then -- debug;
display(decode_method("SET",class,method))
puts(1,"\tArgs: ")
display(decode_args(method,args),
{2,2,11,78,"%d","%2.22f",32,127,1,0})
puts(1,"\n")
end ifdef
if equal("set_name",property) then
p8 = find(handle,vslice(registry,1))
registry[p8][4] = p1
end if
if method[RETVAL] = 0 then -- it's a GTK proc;
c_proc(method[VECTOR],args)
end if
if method[RETVAL] > 0 then -- it's a GTK func;
result = c_func(method[VECTOR],args)
end if
if method[RETVAL] <-1 then -- it's a Eu func;
result = call_func(-method[VECTOR],args)
end if
if method[VECTOR] = -1 then -- GTK doesn't know about this method!
printf(1,
"Warning: %s->%s call is invalid," &
"******** perhaps you need a later GTK version",
{widget[class][$],property})
end if
if not equal("set_data",property) then
for i = 1 to length(allocated) do
free(allocated[i])
end for
end if
return result
end function
-----------------------------------------------------------------------------------
export function get(object handle, sequence property,
object p1=MINF, object p2=MINF, object p3=MINF, object p4=MINF, object p5=MINF)
-----------------------------------------------------------------------------------
-- This routine gets one or more values for a given property name.
-- Property name is always a string, handle is usually an atom,
-- but may sometimes be a string in order to work with Glade.
-----------------------------------------------------------------------------------
integer class
object name = "unknown"
if string(handle) then
name = handle
handle = pointer(handle)
end if
class = vlookup(handle,registry,1,2,-1) -- get widget's class;
if class = -1 then
return 0
end if
property = "get_" & lower(join(split(property,' '),'_'))
object method = lookup_method(class,property)
if atom(method) then -- not found, try fallback to Object;
return get_property(handle,property[5..$])
end if
-- else, method found;
object params = method[PARAMS]
if method[VECTOR] = -1 then
crash("\nERROR:\n****** Invalid call: %s->%s",{widget[class][$],method[1]})
end if
object result = {}
if string(p1) then p1 = allocate_string(p1,1) end if
if string(p2) then p2 = allocate_string(p2,1) end if
if string(p3) then p3 = allocate_string(p3,1) end if
if string(p4) then p4 = allocate_string(p4,1) end if
object args = {handle,allocate(8,1),allocate(8,1),allocate(8,1),allocate(8,1)}
if p1 > MINF then args[2]=p1 end if
if p2 > MINF then args[3]=p2 end if
if p3 > MINF then args[4]=p3 end if
if p4 > MINF then args[5]=p4 end if
args = args[1..length(params)]
ifdef GET then -- debug
display(decode_method("GET",class,method),0)
puts(1,"\tArgs: ")
display(decode_args(method,args),
{2,2,11,78,"%d","%2.22f",32,127,4,-1})
end ifdef
-----------------------------------------------------------------------------------
if method[RETVAL] = 0 then -- it's a GTK proc, may have multiple return values;
c_proc(method[VECTOR],args)
result = repeat(0,length(args))
for i = 1 to length(args) do
switch params[i] do -- convert arg pointer to value;
case D then result[i] = float64_to_atom(peek({args[i],8}))
case F then result[i] = float32_to_atom(peek({args[i],4}))
case I then result[i] = peek4s(args[i])
case B then result[i] = peek(args[i])
case A then result[i] = unpack_gs_str_list(args[i])
case X then result[i] = unpack_gs_atom_list(args[i])
case V then result[i] = deallocate_string_pointer_array(args[i])
case S then if args[i] > 0 then result[i] = peek_string(args[i]) end if
case else result[i] = args[i]
end switch
end for
result = result[2..$] -- don't return handle, just results;
goto "fini"
end if
--------------------------------------------------
if method[RETVAL] > 0 then -- it's a GTK func;
result = c_func(method[VECTOR],args)
switch method[RETVAL] do -- convert function result to value;
case A then result = unpack_gs_str_list(result)
case X then result = unpack_gs_atom_list(result)
case V then result = deallocate_string_pointer_array(result)
case S then if result > 0 then result = peek_string(result) else result = 0 end if
case I then
switch method[1] do -- patch for zero-based indexing;
case
"get_active",
"get_text_column",
"get_pixbuf_column",
"get_column",
"get_tooltip_column",
"get_search_column",
"get_current_page",
"get_index",
"get_item_index",
"page_num",
"get_sort_column_id" then result += 1
end switch
end switch
goto "fini"
end if
----------------------------------------------------------------------
if method[RETVAL] <-1 then -- it's a Eu func (negated routine_id);
result = call_func(-method[VECTOR],args)
end if
label "fini"
if method[CLASS] != GSList then -- for widgets created 'internally' by GTK
if method[CLASS] != 0 then -- as a result of creating a parent widget;
if not initialized[method[CLASS]] then init(method[CLASS]) end if
if atom(result) then register(result,method[CLASS])
else for z = 1 to length(result) do
register(result[z],method[CLASS]) -- must be registered;
end for
end if
end if
end if
ifdef GET then display("\tReturns: []\n",{result}) end ifdef
return result
end function
---------------------------------------------------
public function add(object parent, object child) -- add widgets to container;
---------------------------------------------------
ifdef ADD then
display("Add [] []",{parent,child})
end ifdef
if atom(child) and child = 0 then
display("Null pointer passed to add()\n")
return 0
end if
if class_id(child) = GdkPixbuf then -- issue a warning;
return Warn(,,"Cannot add a pixbuf to a container",
"Create an image from it first,\nthen add the image.",,child)
end if
if class_id(parent) = GtkBuilder then
load_builder(parent,child)
return 1
end if
if string(parent) then -- convert to handle;
parent = pointer(parent)
end if
if string(child) then -- convert to handle;
child = pointer(child)
end if
-- Switch below implements an easier-to-remember 'add' syntax
-- as an alias for the various 'set' calls shown.
-- The GTK original is still available, if you wish to use it.
switch class_id(parent) do
case GtkComboBoxText, GtkComboBoxEntry then
for i = 1 to length(child) do
set(parent,"append text",child[i])
end for
case GtkToolbar then
if atom(child) then
set(parent,"insert",child,-1)
else for i = 1 to length(child) do
add(parent,child[i])
end for
end if
return child
case GtkFileChooserDialog then
if atom(child) then
if class_id(child) = GtkFileFilter then
set(parent,"add filter",child)
end if
else for i = 1 to length(child) do
add(parent,child[i])
end for
end if
case GtkSizeGroup then
set(parent,"add widgets",child)
return child
case GtkTextTagTable then
set(parent,"add",child)
return child
case GtkTreeView then
set(parent,"append columns",child)
return child
case else
if atom(child) then
gtk_proc("gtk_container_add",{P,P},{parent,child})
else
for i = 1 to length(child) do
gtk_proc("gtk_container_add",{P,P},{parent,child[i]})
end for
end if
return child
end switch
return -1
end function
------------------------------------------------------------------------
public function pack(object parent, object child,
integer expand=0, integer fill=0, integer padding=0)
------------------------------------------------------------------------
-- pack a child widget or {list} of child widgets into parent container;
-- prepending a negative sign to the child pointer means
--'pack end'. this is an alias which is sometimes useful.
------------------------------------------------------------------------
if string(parent) then parent = pointer(parent) end if
if string(child) then child = pointer(child) end if
if atom(child) then
if child > 0 then
pack_start(parent,child,expand,fill,padding)
else
child = -child
pack_end(parent,child,expand,fill,padding)
end if
else
for i = 1 to length(child) do
pack(parent,child[i],expand,fill,padding)
end for
end if
return abs(child)
end function
function valid(object x)
object msg = "Invalid object []"
atom p
if string(x) then
p = pointer(x)
if p = 0 then
display(msg,{x})
return 0
else return p
end if
end if
if x = 0 then
display(msg)
end if
return x
end function
-- following 2 functions provided for compatibility with GTK calls;
public function pack_start(object parent, object child,
boolean expand=0, boolean fill=0, integer padding=0)
parent = valid(parent)
child = valid(child)
set(parent,"pack start",child,expand,fill,padding)
return child
end function
public function pack_end(object parent, object child,
boolean expand=0, boolean fill=0, integer padding=0)
parent = valid(parent)
child = valid(child)
set(parent,"pack end",child,expand,fill,padding)
return child
end function
----------------------------------
public procedure show(object x) -- show widget x or a {list} of widgets;
----------------------------------
if string(x) then x = pointer(x) end if
if atom(x) then
set(x,"show")
else
for i = 1 to length(x) do
show(x[i])
end for
end if
end procedure
-------------------------------------
public function show_all(object x) -- show container x and all children;
-------------------------------------
if string(x) then x = pointer(x) end if
if atom(x) then
set(x,"show all")
else
for i = 1 to length(x) do
set(x[i],"show all")
end for
end if
return 1
end function
---------------------------------
public function hide(object x) -- hide a widget or a {list} of widgets;
---------------------------------
if string(x) then x = pointer(x) end if
if atom(x) then
set(x,"hide")
else
for i = 1 to length(x) do
hide(x[i])
end for
end if
return 1
end function
--------------------------------------
public procedure hide_all(object x) -- hide container x and any children it contains;
--------------------------------------
set(x,"hide all")
end procedure
--------------------------------------
export function destroy(object ctl) -- destroy a widget or {list} of widgets;
--------------------------------------
if sequence(ctl) then
for i = 1 to length(ctl) do
destroy(ctl[i])
end for
else
if ctl > 0 then
set(ctl,"destroy")
deregister(ctl)
end if
end if
return 1
end function
--------------------------
export procedure main() -- start the GTK engine;
--------------------------
gtk_proc("gtk_main")
end procedure
without warning {not_reached}
--------------------------------------------------------------------------
export function Quit(atom ctl=0, object errcode=0) -- kill the GTK engine;
--------------------------------------------------------------------------
abort(errcode)
return 1
end function
export constant main_quit = call_back(routine_id("Quit"))
with warning {not_reached}
----------------------------------
function numeric_test(object x) -- convert numbers passed in key=value format;
----------------------------------
atom z
if atom(x) then
return x
end if
if string(x) then
if equal("TRUE",x) then return 1 end if
if equal("FALSE",x) then return 0 end if
if equal("YES",x) then return 1 end if
if equal("NO",x) then return 0 end if
if equal("VERTICAL",x) then return 1 end if
if equal("CENTER",x) then return 1 end if
if equal("HORIZONTAL",x) then return 0 end if
z = to_number(x)
if z != 0 then
ifdef NUM then display("string [] converted to number []",{x,z}) end ifdef
return z
else
ifdef NUM then display("returning string '[]'",{x}) end ifdef
return x
end if
end if
ifdef NUM then display("error []",x) end ifdef
return x
end function
------------------------------------------------------------------------
-- Following functions register and initialize class methods
------------------------------------------------------------------------
-- A class is initialized the first time a widget of that class is created.
-- This means the widget's method vectors are filled in with Eu routine_ids,
-- either direct or generated by define_c_func or define_c_proc as appropriate.
-- When a subsequent call is made to a widget method, that vector is
-- used by calling c_func, c_proc, or call_func.
-- If the call is to a method not implemented by the widget, but is
-- instead a method inherited from one of the widget's ancestors,
-- then that ancestor is also initialized if necessary.
-- This scheme means that program startup isn't delayed as it would be
-- if all 300+ widgets and nearly 4000 methods were to be initialized
-- first, most of which would likely never be used in any given program.
------------------------------------------------------------------------
global procedure init(integer class)
------------------------------------------------------------------------
object name, params, retval
ifdef INITX then
display("\nInit class:[] []",{class,widget[class][$]})
display(widget[class])
end ifdef
if initialized[class] then return end if
for method = 3 to length(widget[class])-1 do
name = sprintf("+%s_%s",{widget[class][NAME],widget[class][method][NAME]})
widget[class][method] = pad_tail(widget[class][method],5,0)
params = widget[class][method][PARAMS]
retval = widget[class][method][RETVAL]
if class = GtkSpinButton then
switch widget[class][method][NAME] do
case "get_increments","get_range" then params[2] = P params[3] = P
case else -- do nothing;
end switch
end if
if widget[class][method][RETVAL] = 0 then -- it's a GTK proc
widget[class][method][VECTOR] = define_proc(name,params)
goto "init"
end if
if widget[class][method][RETVAL] > 0 then -- it's a GTK func
widget[class][method][VECTOR] = define_func(name,params,retval)
goto "init"
end if
if widget[class][method][RETVAL] < -1 then -- it's a Eu func
widget[class][method][VECTOR] = widget[class][method][RETVAL]
end if
label "init"
initialized[class] = TRUE
ifdef INIT then
display("INIT: [].[] RID:[]",
{widget[class][$],widget[class][method][NAME],widget[class][method][VECTOR]})
end ifdef
ifdef INIT_ERR then
if widget[class][method][VECTOR] = -1 then -- function is invalid!
display("\tINIT ERROR: [].[] ERR:[]",
{widget[class][$],widget[class][method][NAME],widget[class][method][VECTOR]})
end if
end ifdef
end for
end procedure
------------------------------------------------------------------------
-- The registry associates a control's handle with its class,
-- so that future calls to set or get that control's properties
-- can go directly to the correct set of functions stored in the
-- large widget{} structure.
------------------------------------------------------------------------
export object registry = {}
----------------------------------------------------------------------------------------
global function register(atom handle, integer class, object name="-nil-", object v=math:MINF)
----------------------------------------------------------------------------------------
integer x = find(handle,vslice(registry,1))
if x > 0 then -- handle already exists in the registry,
ifdef REG_DUP then -- debug
display("Note: [] handle [] already registered to [] []",
{widget[class][$],handle,registry[x][3],name})
end ifdef
-- update it in case handle has been recycled.
registry[x] = {handle,class,widget[class][$],name,v}
return 1
end if
-- else, add the widget to the registry;
registry = append(registry,{handle,class,widget[class][$],name,v})
-- initialize class if this is the first use of that class;
if not initialized[class] then init(class) end if
ifdef REG then -- debug
printf(1,text:format("Registry + [3:20]\thandle: [1:10>]\tname: [4]\tvalue: [5]\n",registry[$]))
end ifdef
return 1
end function
------------------------------------
procedure deregister(atom handle) -- when object no longer used;
------------------------------------
integer x = find(handle,vslice(registry,1))
if x > 0 then
ifdef REG then
printf(1,text:format("Registry - [3:16]\thandle: [1:12>]\t",registry[x]))
if string(registry[x][4]) then printf(1,"name: %s",{registry[x][4]}) end if
puts(1,"\n")
end ifdef
registry = remove(registry,x)
end if
end procedure
-----------------------------------------
public function class_id(object handle) -- returns an integer widget class;
-----------------------------------------
if string(handle) then handle = pointer(handle) end if
return vlookup(handle,registry,1,2,-1)
end function
-------------------------------------------
public function class_name(object handle) -- returns class_name for a given handle;
-------------------------------------------
if string(handle) then handle = pointer(handle) end if
return vlookup(handle,registry,1,3,"!")
end function
------------------------------------------
public function object_name(atom handle) -- returns name of object, or -nil-;
------------------------------------------
return vlookup(handle,registry,1,4,"!")
end function
---------------------------------------
public function pointer(object name) -- returns handle to object or null,
---------------------------------------
return vlookup(name,registry,4,1,0)
end function
------------------------------------------------------------------------
function lookup_method(integer class, sequence prop)
------------------------------------------------------------------------
-- Finds the method to set or get a property for a given class,
-- if not found, ancestors of that class are checked until the method
-- is located.
if class = -1 then return 0 end if
ifdef LOOK then display("Look []->[]",{widget[class][$],prop}) end ifdef
object method = lookup(prop,vslice(widget[class],NAME),widget[class],0)
ifdef LOOKUP then display(widget[class][$]) end ifdef
if atom(method) then -- try sans the set_ or get_ prefix;
method = lookup(prop[5..$],vslice(widget[class],NAME),widget[class],0)
end if
if sequence(method) then -- method was found in this class, we're done!
return method
end if
object ancestor -- if not found, need to look for method in ancestors;
for i = 1 to length(widget[class][PARAMS]) do
ancestor = widget[class][PARAMS][i]
if ancestor = 0 then return 0 end if
if not initialized[ancestor] then
init(ancestor)
end if
ifdef LOOKUP then -- debug;
display("trying ancestor: []",{widget[ancestor][$]})
end ifdef
method = lookup(prop,vslice(widget[ancestor],NAME),widget[ancestor],0)
if atom(method) then
method = lookup(prop[5..$],vslice(widget[ancestor],NAME),widget[ancestor],0)
end if
if sequence(method) then -- found it!
ifdef LOOKUP then display("\t []",{method[1]}) end ifdef
return method
end if
end for
return -1 -- method not found (not implemented)
end function
-----------------------------------------------------------------------------
public function connect(object ctl, object sig, object fn=0, object data=0,
atom closure=0, integer flags=0)
-----------------------------------------------------------------------------
-- tells control to call your Eu function, sending data along for the ride,
-- whenever that control gets the specified signal.
integer result = -1
atom rid = 0
if atom(fn) and fn = 0 then -- no point in registering null functions!
return 0
end if
if string(ctl) then
ctl = pointer(ctl) -- convert name to pointer;
end if
if sequence(ctl) then
for i = 1 to length(ctl) do
connect(ctl[i],sig,fn,data,closure,flags)
end for
return 1
end if
if string(fn) then -- if interpreted, we can call functions by name if in scope;
ifdef COMPILE then -- do compile test if requested;
display("Connecting [] [] Signal '[]' Function [] Data []",
{class_name(ctl),ctl,sig,fn,data})
if not equal("Quit",fn) then
printf(1,"\n\tCaution: function %s will not link when compiled!\n\t********\n",{fn})
end if
end ifdef
rid = routine_id(fn)
if rid > 0 then -- named function is in scope;
fn = call_back(rid) -- so obtain a callback;
else
printf(1,"\n\tError: function %s is not in scope\n\t****** (make it global or link via routine_id)\n",{fn})
Warn(,,sprintf("function %s </b> is not in scope<b>",{fn}),"make it global or link via routine_id")
end if
end if
sig = join(split(sig,' '),'-') -- normalize signal names;
sig = allocate_string(sig) -- convert to string pointer;
if integer(data) then -- can be attached directly;
result = gtk_func("g_signal_connect_data",{P,S,P,P,I,I},{ctl,sig,fn,data,closure,flags})
free(sig)
return result
end if
if atom(data) then
data = prepend({data},"ATOM") -- must be serialized and unpacked later;
data = allocate_wstring(serialize(data)+1)
result = gtk_func("g_signal_connect_data",{P,S,P,P,I,I},{ctl,sig,fn,data,closure,flags})
free(sig)
return result
end if
if string(data) then
data = prepend({data},"STR") -- must be serialized and unpacked later;
data = allocate_wstring(serialize(data)+1)
result = gtk_func("g_signal_connect_data",{P,S,P,P,I,I},{ctl,sig,fn,data,closure,flags})
free(sig)
return result
end if
if sequence(data) then
data = prepend(data,"SEQ")-- must be serialized and unpacked later;
data = allocate_wstring(serialize(data)+1)
result = gtk_func("g_signal_connect_data",{P,S,P,P,I,I},{ctl,sig,fn,data,closure,flags})
free(sig)
return result
end if
end function
-------------------------------------------------------
export procedure disconnect(atom ctl, integer sigid) -- disconnect a signal from ctl;
-------------------------------------------------------
gtk_proc("g_signal_handler_disconnect",{P,I},{ctl,sigid})
end procedure
--------------------------------------
export function unpack(object data) -- retrieves data passed in a control's data space;
--------------------------------------
if atom(data) and data = 0 then return 0 end if
object result = deserialize(peek_wstring(data)-1)
switch result[1][1] do
case "ATOM","STR","INT" then return result[1][2]
case "SEQ" then return result[1][2..$]
case else return result
end switch
end function
-------------------------------------------------------
export function deallocate_string_pointer_array(atom x)
-------------------------------------------------------
integer i = 0
object result = {}
while peek4u(x+i) > 0 do
result = append(result,peek_string(peek4u(x+i)))
i += 8
end while
return result
end function
------------------------------------------------------------------------
-- following 3 'decode_x' functions are for debugging purposes,
-- they make displays more readable;
------------------------------------------------------------------------
function decode_args(object method, object args)
------------------------------------------------------------------------
for i = 1 to length(method[PARAMS]) do
switch method[PARAMS][i] do
case S then
if atom(args[i]) and args[i] > 0 then
args[i] = peek_string(args[i])
if length(args[i]) > 40 then
args[i] = args[i][1..40] & "..."
end if
args[i] = args[i]
end if
case else -- do not convert
end switch
end for
return args
end function
constant ptype = {0,P,I,D,F,S,B,A}
constant pname = {{},"None","Ptr ","Int ","Dbl ","Flt ","Str ","Bool ","Array "}
------------------------------------------------------------------------
function decode_params(object params)
------------------------------------------------------------------------
return transmute(params,ptype,pname)
end function
------------------------------------------------------------------------
function decode_method(sequence title, integer class, object method)
------------------------------------------------------------------------
object z = {}
integer n
z = prepend(method,widget[class][$])
z = prepend(z,title)
z[4] = decode_params(method[PARAMS])
while length(z) < 5 do
z = append(z,0)
end while
if length(method) >= RETVAL then
n = find(method[RETVAL],ptype)
z[5] = pname[n+1]
end if
return text:format("[]\n\tCall: []->[]\n\tParams: []\n\tReturn type: []\n\tVector: []",z)
end function
---------------------------------------------------------
public function to_sequence(atom glist, integer fmt=0) -- mostly internal use;
---------------------------------------------------------
-- convert glist pointer back to a Euphoria sequence;
-- results are returned in a choice of formats;
integer len = gtk_func("g_list_length",{P},{glist})
object s = {}
atom data
for i = 0 to len-1 do
data = gtk_func("g_slist_nth_data",{P,I},{glist,i})
switch fmt do
case 0 then s = append(s,peek_string(data))
case 1 then s = append(s,data)
case 2 then s = append(s,gtk_str_func("gtk_tree_path_to_string",{P},{data}))
case 3 then s = append(s,to_number(gtk_str_func("gtk_tree_path_to_string",{P},{data})))
case else Warn(,,"Converting glist to_sequence",
"invalid format supplied,\nvalues are 0 to 3")
end switch
end for
return s
end function
-----------------------------------------------------------------------------------------
-- METHOD DECLARATIONS:
-----------------------------------------------------------------------------------------
sequence initialized = repeat(0,500)
-- This is a set of flags which are set to 1 when a given widget has
-- been initialized. This prevents having to initialize a widget's
-- methods repeatedly. Size is larger than GtkFinal to allow 'plugin'
-- widgets to be added at runtime.
export sequence widget = repeat(0,GtkFinal)
-- This structure holds prototypes for each GTK method call,
-- organized by widget. When each widget is initialized,
-- vectors are added pointing to the routine_ids needed
-- to call the GTK functions that implement each method.
-- The widgets below need not be in any specific order.
-- Widget names must also be added to the list in GtkEnums
sequence stock_list = create(GtkStockList) -- a fake object;
widget[GObject] = {"g_object",
{0},
{"new",{I,S,S,I},P},
{"set",{P,S,P,P}},
{"set_property",{P,S,P},-routine_id("set_property")},
{"get_property",{P,S},-routine_id("get_property")},
{"get_data",{P,P},S},
{"set_data",{P,S,S}},
{"set_data_full",{P,S,S,P}},
{"steal_data",{P,S},P},
{"signal",{P,P,P,P,P,P},-routine_id("connect")},
{"connect",{P,P,P,P,P,P},-routine_id("connect")},
"GObject"}
constant
fn1 = define_proc("g_object_get",{P,P,P,P}),
doubles = {"angle","climb-rate","fraction","max-value","min-value",
"scale","value","pulse-step","scale","size-points","text-xalign",
"text-yalign","xalign","yalign"}
constant prop = allocate_string("property")
function set_property(object handle, object a, object b)
--------------------------------------------------------------
object params = {P,P,P,P}
if find(a,doubles) then params = {P,P,D,P} end if
if string(a) then a = allocate_string(a,1) end if
if string(b) then b = allocate_string(b,1) end if
gtk_proc("g_object_set",params,{handle,a,b,0})
return 1
end function
function get_property(atom handle, object p)
--------------------------------------------------
atom x = allocate(8,1)
if string(p) then p = allocate_string(p,1) end if
c_proc(fn1,{handle,p,x,0})
object result = peek4u(x)
return result
end function
widget[GtkAdjustment] = {"gtk_adjustment",
{GObject},
{"new",{D,D,D,D,D,D},P},
{"set_value",{P,D}},
{"get_value",{P},D},
{"clamp_page",{P,D,D}},
{"value_changed",{P}},
{"configure",{P,D,D,D,D,D,D}},
{"get_lower",{P},D},
{"get_page_increment",{P},D},
{"get_step_increment",{P},D},
{"get_minimum_increment",{P},D},
{"set_upper",{P,D}},
{"get_upper",{P},D},
{"set_page_increment",{P,D}},
{"set_page_size",{P,D}},
{"set_step_increment",{P,D}},
{"set_upper",{P,D}},
"GtkAdjustment"}
widget[GtkWidgetPath] = {"gtk_widget_path",
{GObject},
{"new",{},P},
{"append_type",{P,I},I},
{"append_with_siblings",{P,P,I},I},
{"append_for_widget",{P,P},I},
{"copy",{P},P,0,GtkWidgetPath},
{"get_object_type",{P},I},
{"has_parent",{P,I},B},
{"is_type",{P,I},B},
{"iter_add_class",{P,I,S}},
{"iter_add_region",{P,I,S,I}},
{"iter_clear_classes",{P,I}},
{"iter_clear_regions",{P,I}},
{"iter_get_name",{P,I},S},
{"iter_get_object_type",{P,I},I},
{"iter_get_siblings",{P,I},P,0,GtkWidgetPath},
{"iter_get_sibling_index",{P,I},I},
{"iter_has_class",{P,I,S},B},
{"iter_has_name",{P,I,S},B},
{"iter_has_qclass",{P,I,P},B},
{"iter_has_qname",{P,I,P},B},
{"iter_has_qregion",{P,I,P,I},B},
{"iter_has_region",{P,I,S,I},B},
{"iter_list_classes",{P,I},A,0,GSList},
{"iter_list_regions",{P,I},A,0,GSList},
{"iter_remove_class",{P,I,S}},
{"iter_remove_region",{P,I,S}},
{"iter_set_name",{P,I,S}},
{"iter_set_object_type",{P,I,I}},
{"iter_set_object_name",{P,I,S}}, -- 3.20
{"iter_get_object_name",{P,I},S}, -- 3.20
{"iter_get_state",{P,I},I}, -- 3.14
{"iter_set_state",{P,I,I}}, -- 3.14
{"length",{P},I},
{"prepend_type",{P,I}},
{"to_string",{P},S},
{"get_object_name",{P,I},S}, -- 3.20
{"set_object_name",{P,I,S}}, -- 3.20
"GtkWidgetPath"}
widget[GtkStyle] = {"gtk_style",
{GObject},
"GtkStyle"}
widget[GAction] = {"g_action",
{GObject},
{"name_is_valid",{S},B},
{"get_name",{P},S},
{"get_parameter_type",{P},I},
{"get_state_type",{P},I},
{"get_state_hint",{P},I},
{"get_enabled",{P},B},
{"get_state",{P},I},
{"change_state",{P,I}},
{"activate",{P,I}},
{"parse_detailed_name",{P,S,P,P},B},
{"print_detailed_name",{P,I},S},
"GAction"}
widget[GSimpleAction] = {"g_simple_action",
{GObject},
{"new",{S,I},P},
{"new_stateful",{S,I,I}},
{"set_enabled",{P,B}},
{"set_state",{P,I}},
{"set_state_hint",{P,I}},
"GSimpleAction"}
widget[GPropertyAction] = {"g_property_action",
{GObject},
{"new",{S,P,S},P},
"GPropertyAction"}
widget[GActionGroup] = {"g_action_group",
{GSimpleAction,GObject},
"GActionGroup"}
widget[GSimpleActionGroup] = {"g_simple_action_group",
{GApplication,GActionGroup,GObject},
{"new",{}},
"GSimpleActionGroup"}
widget[GActionMap] = {"g_action_map",
{0},
{"lookup_action",{P,S},P},
{"add_action_entries",{P,P,I,P}},
{"add_action",{P,P}},
{"remove_action",{P,S}},
"GActionMap"}
widget[GtkWidgetClass] = {"gtk_widget_class",
{GtkWidget,GtkBuildable,GObject},
{"set_template",{P,P}}, -- 3.10
{"set_template_from_resource",{P,S}}, -- 3.10
{"get_template_child",{P,I,S},P,0,GObject},
{"bind_template_child_full",{P,S,B,I}},
{"bind_template_callback_full",{P,S,P}},
{"set_connect_func",{P,P,P,P}},
{"set_css_name",{P,S}}, -- 3.20
{"get_css_name",{P},S}, -- 3.20
"GtkWidgetClass"}
widget[GtkWidget] = {"gtk_widget",
{GtkBuildable,GObject},
-- Aliases to fix awkward overrides; ordinarily you will use one of these 4,
{"set_font",{P,S},-routine_id("widget_set_font")},
{"set_color",{P,P},-routine_id("widget_set_foreground")},
{"set_foreground",{P,P},-routine_id("widget_set_foreground")},
{"set_background",{P,P},-routine_id("widget_set_background")},
-- Only use following versions when you need to change the color
-- of a control in a state other than normal. Rarely used since themes
-- often disallow the use of stateful colors;
{"override_background_color",{P,I,P},-routine_id("widget_override_background_color")},
{"override_color",{P,I,P},-routine_id("widget_override_color")},
----
{"new",{I},P},
{"destroy",{P}},
{"in_destruction",{P},B},
{"destroyed",{P},B},
{"unparent",{P}},
{"show",{P}},
{"show_now",{P}},
{"hide",{P}},
{"show_all",{P}},
{"map",{P}},
{"unmap",{P}},
{"realize",{P}},
{"unrealize",{P}},
{"draw",{P}},
{"queue_draw",{P}},
{"queue_resize",{P}},
{"queue_resize_no_redraw",{P}},
{"get_frame_clock",{P},P,0,GdkFrameClock},
{"add_tick_callback",{P,P,P,P},I},
{"remove_tick_callback",{P,I}}, -- GTK 3.8+
{"set_size_request",{P,P,P},-routine_id("widget_set_size_request")},
{"size_allocate",{P,P}},
{"size_allocate_with_baseline",{P,P,I}},
{"add_accelerator",{P,S,P,I,I}},
{"remove_accelerator",{P,P,I,I},B},
{"set_accel_path",{P,S,P}},
{"can_activate_accel",{P,I},B},
{"event",{P,P},B},
{"activate",{P},B},
{"reparent",{P,P}}, -- deprecated 3.14
{"intersect",{P,P,P},B},
{"is_focus",{P},B},
{"grab_focus",{P},B},
{"grab_default",{P}},
{"set_name",{P,S},-routine_id("widget_set_name")},
{"get_name",{P},S},
{"set_sensitive",{P,B}},
{"get_sensitive",{P},B},
{"set_parent",{P,P}},
{"get_parent",{P},P},
{"set_parent_window",{P,P}},
{"get_parent_window",{P},P},
{"set_events",{P,I}},
{"get_events",{P},I},
{"add_events",{P,I}},
{"set_device_events",{P,P,I}},
{"get_device_events",{P,P},I},
{"add_device_events",{P,P,I}},
{"set_device_enabled",{P,P,B}},
{"get_device_enabled",{P,P},B},
{"get_toplevel",{P},P},
{"get_ancestor",{P,I},P},
{"is_ancestor",{P,P},B},
{"set_visual",{P,P}},
{"get_visual",{P},P,0,GdkVisual},
{"get_pointer",{P,I,I}}, -- deprecated 3.4
{"translate_coordinates",{P,P,I,I,I,I},B},
{"hide_on_delete",{P},B},
{"set_direction",{P,I}},
{"get_direction",{P},I},
{"set_default_direction",{I}},
{"get_default_direction",{},I},
{"shape_combine_region",{P,P}},
{"create_pango_context",{P},P},
{"get_pango_context",{P},P,0,PangoContext},
{"create_pango_layout",{P,S},P},
{"queue_draw_area",{P,I,I,I,I}},
{"queue_draw_region",{P,P}},
{"set_app_paintable",{P,B}},
{"set_double_buffered",{P,B}}, -- deprecated 3.14
{"set_redraw_on_allocate",{P,B}},
{"mnemonic_activate",{P,B},B},
{"send_expose",{P,P},I},
{"send_focus_change",{P,P},B},
{"get_accessible",{P},P},
{"child_focus",{P,I},B},
{"child_notify",{P,S}},
{"freeze_child_notify",{P}},
{"get_child_visible",{P},B},
{"get_parent",{P},P},
{"get_path",{P},P,0,GtkWidgetPath},
{"get_settings",{P},P,0,GtkSettings},
{"get_clipboard",{P,I},P,0,GtkClipboard},
{"get_display",{P},P,0,GdkDisplay},
{"get_root_window",{P},P,0,GdkWindow}, -- deprecated 3.12
{"get_screen",{P},P,0,GdkScreen},
{"has_screen",{P},B},
{"get_size_request",{P,I,I}},
{"set_child_visible",{P,B}},
{"thaw_child_notify",{P}},
{"set_no_show_all",{P,B}},
{"get_no_show_all",{P},B},
{"add_mnemonic_label",{P,P}},
{"remove_mnemonic_label",{P,P}},
{"is_composited",{P},B},
{"set_tooltip_markup",{P,S}},
{"get_tooltip_markup",{P},S},
{"set_tooltip_text",{P,S}},
{"get_tooltip_text",{P},S},
{"set_tooltip_window",{P,P}},
{"get_tooltip_window",{P},P,0,GtkWindow},
{"set_has_tooltip",{P,B}},
{"get_has_tooltip",{P},B},
{"trigger_tooltip_query",{P}},
{"get_window",{P},P,0,GdkWindow},
{"register_window",{P,P}}, -- GTK 3.8+
{"unregister_window",{P,P}}, -- GTK 3.8+
{"get_allocated_width",{P},I},
{"get_allocated_height",{P},I},
{"get_allocation",{P},-routine_id("widget_get_allocation")},
{"set_allocation",{P,P}},
{"get_allocated_baseline",{P},I},
{"get_app_paintable",{P},B},
{"set_can_default",{P,B}},
{"get_can_default",{P},B},
{"get_can_focus",{P},B},
{"get_double_buffered",{P},B}, -- deprecated 3.14
{"get_has_window",{P},B},
{"get_sensitive",{P},B},
{"get_visible",{P},B},
{"is_visible",{P},B}, -- GTK 3.8+
{"set_visible",{P,B}},
{"set_state_flags",{P,I,B}},
{"unset_state_flags",{P,I}},
{"get_state_flags",{P},I},
{"has_default",{P},B},
{"has_focus",{P},B},
{"has_visible_focus",{P},B},
{"has_grab",{P},B},
{"is_drawable",{P},B},
{"is_toplevel",{P},B},
{"set_window",{P,P}},
{"set_receives_default",{P,B}},
{"get_receives_default",{P},B},
{"set_support_multidevice",{P,B}},
{"get_support_multidevice",{P},B},
{"set_realized",{P,B}},
{"get_realized",{P},B},
{"set_mapped",{P,B}},
{"get_mapped",{P},B},
{"device_is_shadowed",{P,P},B},
{"get_modifier_mask",{P,I},I},
{"insert_action_group",{P,S,P}},
{"get_opacity",{P},D}, -- GTK 3.8+
{"set_opacity",{P,D}}, -- GTK 3.8+
{"get_path",{P},P,0,GtkWidgetPath},
{"get_style",{P},P,0,GtkStyle},
{"get_style_context",{P},P,0,GtkStyleContext},
{"reset_style",{P}},
{"get_preferred_height",{P,I,I}},
{"get_preferred_width",{P,I,I}},
{"get_preferred_height_for_width",{P,I,I,I}},
{"get_preferred_width_for_height",{P,I,I,I}},
{"get_preferred_height_and_baseline_for_width",{P,I,I,I,I,I}},
{"get_request_mode",{P},I},
{"get_preferred_size",{P,P,P}},
{"get_preferred_size_and_baseline",{P,P,I,I}},
{"get_halign",{P},I},
{"set_halign",{P,I}},
{"get_valign",{P},I},
{"set_valign",{P,I}},
{"set_margin_left",{P,I}}, -- deprecated 3.12
{"get_margin_left",{P},I}, -- deprecated 3.12
{"set_margin_right",{P,I}}, -- deprecated 3.12
{"get_margin_right",{P},I}, -- deprecated 3.12
{"get_margin_end",{P},I}, -- new 3.12
{"set_margin_end",{P,I}}, -- new 3.12
{"get_margin_start",{P},I}, -- new 3.12
{"set_margin_start",{P,I}}, -- new 3.12
{"set_margin_top",{P,I}},
{"get_margin_top",{P},I},
{"set_margin_bottom",{P,I}},
{"get_margin_bottom",{P},I},
{"get_hexpand",{P},B},
{"set_hexpand",{P,B}},
{"get_hexpand_set",{P},B},
{"set_hexpand_set",{P,B}},
{"get_vexpand",{P},B},
{"set_vexpand",{P,B}},
{"get_vexpand_set",{P},B},
{"set_vexpand_set",{P,B}},
{"queue_compute_expand",{P}},
{"compute_expand",{P,I},B},
{"init_template",{P}},
{"get_automated_child",{P,I,S},P,0,GObject},
{"get_clip",{P,P}}, -- 3.14
{"set_clip",{P},P}, -- 3.14
{"get_action_group",{P,S},P,0,GActionGroup}, -- 3.16
{"list_action_prefixes",{P},A}, -- 3.16
{"get_font_map",{P},P,0,PangoFontMap}, -- 3.18
{"set_font_map",{P,P}}, -- 3.18
{"get_font_options",{P},P}, -- 3.18
{"set_font_options",{P,P}}, -- 3.18
{"signal",{P,P,P,P,P,P},-routine_id("connect")},
{"list_accel_closures",{P},X,0,GList},
{"get_font",{P},-routine_id("widget_get_font")},
{"get_allocated_size",{P,P,I}}, -- 3.20
{"get_focus_on_click",{P},B}, -- 3.20
{"set_focus_on_click",{P,B}}, -- 3.20
"GtkWidget"}
function widget_set_size_request(atom ctl, object x=0, object y=0)
if string(x) then
x = split(x,'x')
y = to_number(x[2])
x = to_number(x[1])
end if
gtk_func("gtk_widget_set_size_request",{P,I,I},{ctl,x,y})
return 1
end function
function widget_get_font(atom x)
object layout = get(x,"layout")
object context = gtk_func("pango_layout_get_context",{P},{layout})
object descr = gtk_func("pango_context_get_font_description",{P},{context})
return gtk_str_func("pango_font_description_to_string",{P},{descr})
end function
function widget_get_allocation(atom obj)
atom al = allocate(32,1)
gtk_func("gtk_widget_get_allocation",{P,P},{obj,al})
return peek4u({al,4})
end function
function widget_set_name(atom ctl, object name)
gtk_proc("gtk_widget_set_name",{P,P},{ctl,name})
integer x = find(ctl,vslice(registry,1))
if x > 0 then
registry[x][4] = peek_string(name)
end if
return 1
end function
-- This allows specifying a font name, e.g. "Courier bold 12" as a string,
-- instead of a pango font description object;
function widget_set_font(atom x, object fnt)
fnt = gtk_func("pango_font_description_from_string",{P},{fnt})
gtk_proc("gtk_widget_override_font",{P,P},{x,fnt})
return 1
end function
-- The functions below handle color conversion to/from rgba,
-- as well as supplying easier-to-use method names for setting background
-- and foreground. These methods are only used to set the colors of a widget
-- in the NORMAL state, whereas if you want to set the colors in
-- some other state, such as mouse-over, etc, you use the original
-- set(widget,"override background",STATE,"color") syntax.
function widget_set_foreground(atom x, object c) -- alias 'color'
return widget_override_color(x,0,c)
end function
function widget_set_background(atom x, object c) -- alias 'background'
return widget_override_background_color(x,0,c)
end function
function widget_override_color(atom x, integer state=0, object c)
if atom(c) then
c = text:format("#[:06X]",c)
end if
gtk_proc("gtk_widget_override_color",{P,I,P},{x,state,to_rgba(c)})
return 1
end function
function widget_override_background_color(atom x, integer state=0, object c)
if atom(c) then
c = text:format("#[:06X]",c)
end if
gtk_proc("gtk_widget_override_background_color",{P,I,P},{x,state,to_rgba(c)})
return 1
end function
widget[GtkContainer] = {"gtk_container",
{GtkWidget,GtkBuildable,GObject},
{"add",{P,P}},
{"remove",{P,P}},
{"check_resize",{P}},
{"foreach",{P,P,P}},
{"get_children",{P},X},
{"get_path_for_child",{P,P},S},
{"set_focus_child",{P,P}},
{"get_focus_child",{P},P},
{"set_focus_vadjustment",{P,P}},
{"get_focus_vadjustment",{P},P,0,GtkAdjustment},
{"set_focus_hadjustment",{P,P}},
{"get_focus_hadjustment",{P},P,0,GtkAdjustment},
{"child_type",{P},I},
{"forall",{P,P,P}},
{"set_border",{P,I},-routine_id("set_border")},
{"set_border_width",{P,I}},
{"get_border_width",{P},I},
{"propagate_draw",{P,P,P}},
{"child_notify",{P,P,S}},
{"child_notify_by_pspec",{P,P,P}}, -- 3.18
{"class_install_child_properties",{P,I,P}}, -- 3.18
"GtkContainer"}
function set_border(atom cont, integer w) -- alias for 'border_width';
gtk_proc("gtk_container_set_border_width",{P,I},{cont,w})
return 1
end function
widget[GdkKeymap] = {"gdk_keymap",
{GObject},
{"new",{},-routine_id("new_keymap")},
{"get_default",{},-routine_id("new_keymap")},
{"get_for_display",{P},P,0,GdkKeymap},
{"get_capslock_state",{P},B},
{"get_numlock_state",{P},B},
{"get_modifier_state",{P},I},
{"get_direction",{P},I},
{"have_bidi_layouts",{P},B},
{"lookup_key",{P,P},I},
{"get_scroll_lock_state",{P,B}},
"GdkKeymap"}
function new_keymap(atom disp=0)
if disp=0 then
return gtk_func("gdk_keymap_get_default")
else
return gtk_func("gdk_keymap_get_for_display",{P},P)
end if
end function
widget[GtkBin] = {"gtk_bin",
{GtkContainer,GtkWidget,GtkBuildable,GObject},
{"get_child",{P},P},
"GtkBin"}
widget[GtkBox] = {"gtk_box",
{GtkContainer,GtkWidget,GtkOrientable,GtkBuildable,GObject},
{"new",{I,I},P},
{"pack_start",{P,P,B,B,I}},
{"pack_end",{P,P,B,B,I}},
{"set_homogeneous",{P,B}},
{"get_homogeneous",{P},B},
{"set_spacing",{P,I}},
{"get_spacing",{P},I},
{"reorder_child",{P,P,I}},
{"query_child_packing",{P,P,B,B,I,I}},
{"set_child_packing",{P,P,B,B,I,I}},
{"set_baseline_position",{P,I}},
{"get_baseline_position",{P},I},
{"get_center_widget",{P},P,0,GtkWidget}, -- 3.12
{"set_center_widget",{P,P}}, -- 3.12
"GtkBox"}
widget[GtkButtonBox] = {"gtk_button_box",
{GtkBox,GtkContainer,GtkWidget,GtkBuilder,GtkOrientable,GObject},
{"new",{I},P},
{"set_layout",{P,I}},
{"get_layout",{P},I},
{"set_child_secondary",{P,P,B}},
{"get_child_secondary",{P,P},B},
{"set_child_non_homogeneous",{P,P,B}},
{"get_child_non_homogeneous",{P,P},P},
"GtkButtonBox"}
widget[GtkWindowGroup] = {"gtk_window_group",
{GObject},
{"new",{},P},
{"add_window",{P,P}},
{"remove_window",{P,P}},
{"list_windows",{P},X,0,GList},
{"get_current_grab",{P},P,0,GtkWidget},
{"get_current_grab_device",{P,P},P,0,GtkWidget},
"GtkWindowGroup"}
-- shortcuts are new in 3.20, inadequate documentation means there's no way to test yet;
widget[GtkShortcutsWindow] = {"gtk_shortcuts_window",
{GtkWindow,GtkBin,GtkContainer,GtkWidget,GObject},
-- properties:
-- section-name
-- view-name
"GtkShortcutsWindow"}
widget[GtkShortcutsSection] = {"gtk_shortcuts_section",
{GtkBox,GtkContainer,GtkWidget,GObject},
-- properties;
-- max-height
-- section-name
-- title
-- view-name
"GtkShortcutsSection"}
widget[GtkShortcutsGroup] = {"gtk_shortcuts_group",
{GtkBox,GtkContainer,GtkWidget,GObject},
-- properties;
-- accel-size-group
-- height
-- title
-- title-size-group
-- view
"GtkShortcutsGroup"}
widget[GtkShortcutsShortcut] = {"gtk_shortcuts_shortcut",
{GtkBox,GtkContainer,GtkWidget,GObject},
-- properties;
-- accel-size-group
-- accelerator
-- title
-- title-size-group
"GtkShortcutsShortcut"}
widget[GtkShortcutsGesture] = {"gtk_shortcuts_gesture",
{GtkBox,GtkContainer,GtkWidget,GObject},
-- properties;
-- icon
-- icon-size-group
-- subtitle
-- title
-- title-size-group
"GtkShortcutsGesture"}
widget[GtkWindow] = {"gtk_window",
{GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{I},P},
{"set_title",{P,S}},
{"get_title",{P},S},
{"set_resizable",{P,B}},
{"get_resizable",{P},B},
{"get_size",{P,I,I}},
{"set_size",{P,P},-routine_id("win_set_size")}, -- alias;
{"set_position",{P,P},-routine_id("win_set_pos")}, -- alias
--{"set_position",{P,I}}, -- alias above allows 2 forms of 'position';
{"set_default",{P,P}},
{"set_default_size",{P,I,I}},
{"get_default_size",{P,I,I}},
{"get_position",{P,I,I}},
{"add_accel_group",{P,P}},
{"remove_accel_group",{P,P}},
{"activate_focus",{P},B},
{"activate_default",{P},B},
{"set_modal",{P,B}},
{"get_modal",{P},B},
{"set_default_geometry",{P,I,I}},
{"set_geometry_hints",{P,P,P,I}},
{"set_gravity",{P,I}},
{"get_gravity",{P},I},
{"set_transient_for",{P,P}},
{"get_transient_for",{P},P,0,GtkWindow},
{"set_attached_to",{P,P}},
{"get_attached_to",{P},P,0,GtkWidget},
{"set_destroy_with_parent",{P,B}},
{"get_destroy_with_parent",{P},B},
{"set_hide_titlebar_when_maximized",{P,B}},
{"get_hide_titlebar_when_maximized",{P},B},
{"set_screen",{P,P}},
{"get_screen",{P},P,0,GdkScreen},
{"is_active",{P},B},
{"list_toplevels",{P},X,0,GSList},
{"has_toplevel_focus",{P},B},
{"add_mnemonic",{P,I,P}},
{"remove_mnemonic",{P,I,P}},
{"set_mnemonics_visible",{P,B}},
{"get_mnemonics_visible",{P},B},
{"mnemonic_activate",{P,I,I},B},
{"activate_key",{P,P},B},
{"propagate_key_event",{P,P},B},
{"get_focus",{P},P,0,GtkWidget},
{"set_focus",{P,P}},
{"set_focus_visible",{P,B}},
{"get_focus_visible",{P},B},
{"get_default_widget",{P},P,0,GtkWidget},
{"set_default",{P,P}},
{"present",{P}},
{"present_with_time",{P,P}},
{"iconify",{P}},
{"deiconify",{P}},
{"stick",{P}},
{"unstick",{P}},
{"maximize",{P}},
{"unmaximize",{P}},
{"fullscreen",{P}},
{"unfullscreen",{P}},
{"set_keep_above",{P,B}},
{"set_keep_below",{P,B}},
{"begin_resize_drag",{P,I,I,I,I,I}},
{"begin_move_drag",{P,I,I,I,I}},
{"set_decorated",{P,B}},
{"get_decorated",{P},B},
{"set_deletable",{P,B}},
{"get_deletable",{P},B},
{"set_mnemonic_modifier",{P,I}},
{"get_mnemonic_modifier",{P},I},
{"set_type_hint",{P,I}},
{"get_type_hint",{P},I},
{"set_skip_taskbar_hint",{P,B}},
{"get_skip_taskbar_hint",{P},B},
{"set_skip_pager_hint",{P,B}},
{"get_skip_pager_hint",{P},B},
{"set_urgency_hint",{P,B}},
{"get_urgency_hint",{P},B},
{"set_accept_focus",{P,B}},
{"get_accept_focus",{P},B},
{"set_focus_on_map",{P,B}},
{"get_focus_on_map",{P},B},
{"set_startup_id",{P,S}},
{"set_role",{P,S}},
{"get_role",{P},S},
{"get_icon",{P},P,0,GdkPixbuf},
{"get_icon_name",{P},S},
{"get_icon_list",{P},P,0,GList},
{"get_default_icon_list",{P},X,0,GList},
{"get_group",{P},P,0,GtkWindowGroup},
{"has_group",{P},B},
{"get_window_type",{P},I},
{"move",{P,I,I}},
{"parse_geometry",{P,S},B},
{"resize",{P,I,I}},
{"resize_to_geometry",{P,I,I}},
{"set_has_resize_grip",{P,B}},
{"get_has_resize_grip",{P},B},
{"resize_grip_is_visible",{P},B}, -- deprecated 3.14
{"get_resize_grip_area",{P,P},B}, -- deprecated 3.14
{"set_titlebar",{P,P}}, -- 3.10
{"get_titlebar",{P},P,0,GtkWidget}, -- 3.16
{"set_icon",{P,P},-routine_id("win_set_icon")},
{"restore",{P},-routine_id("win_restore")}, -- see below;
{"close",{P}}, -- 3.10
{"set_opacity",{P,D}},
{"is_maximized",{P},B}, -- 3.12
{"set_interactive_debugging",{B}}, -- 3.14
{"fullscreen_on_monitor",{P,P,I}}, -- 3.18
{"set_application",{P,P}},
{"get_application",{P},P,0,GtkApplication},
{"set_cursor",{P,P},-routine_id("win_set_cursor")},
"GtkWindow"}
function win_set_size(atom win, object size)
-- allow for WxH format to be passed;
if match("x",size) then size = split(size,'x') end if
if match("{",size) = 1 and match("}",size) = length(size) then
size = size[2..$-1]
size = split(size,',')
end if
set(win,"default_size",size[1],size[2])
return 1
end function
function win_set_pos(atom win, object pos)
if integer(pos) then -- only one integer passed;
gtk_proc("gtk_window_set_position",{P,I},{win,pos}) -- use original call;
return 1
end if
-- else position is WxH format, so call move instead;
if match("x",pos) then pos = split(pos,'x') end if
if match("{",pos) = 1 and match("}",pos) = length(pos) then
pos = pos[2..$-1]
pos = split(pos,',')
end if
set(win,"move",pos[1],pos[2])
return 1
end function
function win_set_cursor(atom win, object cursor)
atom gdkwin = get(win,"window")
cursor = create(GdkCursor,cursor)
set(gdkwin,"cursor",cursor)
return cursor
end function
-- this replaces a handy but deprecated GTK function which
-- restores a window to its original size after being resized
-- to fit larger contents;
function win_restore(atom win)
set(win,"hide")
set(win,"unrealize")
gtk_proc("gtk_window_set_position",{P,I},{win,1})
set(win,"show")
return 1
end function
-- manages the creation of window icon from a variety of source formats.
-- this makes life much easier for the programmer.
function win_set_icon(object win, object icon)
object path
if string(icon) then
path = locate_file(icon)--display(path)
if file_type(path) = 1 then
gtk_proc("gtk_window_set_icon_from_file",{P,P},
{win,allocate_string(path,1)})
return 1
else
gtk_proc("gtk_window_set_icon_name",{P,P},
{win,allocate_string(icon,1)})
return 1
end if
end if
if sequence(icon) then
gtk_proc("gtk_window_set_icon",{P,P},{win,xpm_to_pixbuf(icon)})
end if
if atom(icon) then
if class_id(icon) = GtkImage then
icon = get(icon,"pixbuf")
end if
if class_id(icon) = GdkPixbuf then
gtk_proc("gtk_window_set_icon",{P,P},{win,icon})
end if
return 1
end if
return 0
end function
widget[GtkMisc] = {"gtk_misc", -- deprecated 3.14
{GtkWidget,GtkBuildable,GObject},
{"set_alignment",{P,F,F}},
{"get_alignment",{P,F,F}},
{"set_padding",{P,I,I}},
{"get_padding",{P,I,I}},
"GtkMisc"}
widget[GtkLabel] = {"gtk_label",
{GtkMisc,GtkWidget,GtkBuildable,GObject},
{"new",{S},P},
{"new_with_mnemonic",{S},P,0,GtkLabel},
{"set_text",{P,S}},
{"set_value",{P,D},-routine_id("lbl_set_value")}, -- convenience, converts # to readable form;
{"get_text",{P},S},
{"set_markup",{P,S}},
{"set_text_with_mnemonic",{P,S}},
{"set_markup_with_mnemonic",{P,S}},
{"set_pattern",{P,S}},
{"set_justify",{P,I}},
{"get_justify",{P},I},
{"get_attributes",{P},P,0,PangoAttrList},
{"set_ellipsize",{P,I}},
{"get_ellipsize",{P},I},
{"set_width_chars",{P,I}},
{"get_width_chars",{P},I},
{"set_max_width_chars",{P,I}},
{"get_max_width_chars",{P},I},
{"set_line_wrap",{P,B}},
{"get_line_wrap",{P},B},
{"set_line_wrap_mode",{P,I}},
{"get_layout_offsets",{P,I,I}},
{"get_mnemonic_keyval",{P},I},
{"set_selectable",{P,B}},
{"get_selectable",{P},B},
{"select_region",{P,I,I}},
{"get_selection_bounds",{P,I,I},B},
{"set_mnemonic_widget",{P,P}},
{"get_mnemonic_widget",{P},P,0,GtkWidget},
{"get_label",{P},S},
{"get_layout",{P},P,0,PangoLayout},
{"get_line_wrap_mode",{P},I},
{"set_use_markup",{P,B}},
{"get_use_markup",{P},B},
{"set_use_underline",{P,B}},
{"get_use_underline",{P},B},
{"set_single_line_mode",{P,B}},
{"get_single_line_mode",{P},B},
{"set_angle",{P,D}},
{"get_current_uri",{P},S},
{"set_track_visited_links",{P,B}},
{"get_track_visited_links",{P},B},
{"set_lines",{P,I}}, -- 3.10
{"get_lines",{P},I}, -- 3.10
{"get_xalign",{P},F}, -- 3.16
{"get_yalign",{P},F}, -- 3.16
{"set_xalign",{P,F}}, -- 3.16
{"set_yalign",{P,F}}, -- 3.16
"GtkLabel"}
function lbl_set_value(atom lbl, atom val) -- provided for convenience;
set(lbl,"text",sprintf("%2.2f",val)) -- convert atom to string for label;
return 1
end function
widget[GtkImage] = {"gtk_image",
{GtkMisc,GtkWidget,GtkBuildable,GObject},
{"new",{P,I,I,I},-routine_id("newImage")},
{"set_image",{P,P,P},-routine_id("setImage")}, -- not a gtk func
{"set_from_file",{P,S}},
{"set_from_pixbuf",{P,P}},
{"set_from_icon_name",{P,S,I}},
{"set_from_animation",{P,P}},
{"set_from_gicon",{P,P,I}},
{"set_from_resource",{P,S}},
{"set_from_surface",{P,P}}, -- 3.10
{"clear",{P}},
{"set_pixel_size",{P,I}},
{"get_pixel_size",{P},I},
{"get_pixbuf",{P},P,0,GdkPixbuf}, -- doesn't work!
{"get_animation",{P},P,0,GdkPixbufAnimation},
{"get_storage_type",{P},I},
{"get_icon_name",{P},-routine_id("img_get_icon_name")},
"GtkImage"}
-----------------------------------------------------
-- create an image from a variety of source formats
----------------------------------------------------
function newImage(object icon=0, integer size=6, integer w=0, integer h=0)
if atom(icon) then
if icon = 0 then
return gtk_func("gtk_image_new") -- just a blank image requested;
else
switch class_id(icon) do
case GdkPixbuf then
icon = gtk_func("gtk_image_new_from_pixbuf",{P},{icon})
case GIcon then
icon = gtk_func("gtk_image_new_from_gicon",{P,I},{icon,size})
case CairoSurface_t then
icon = gtk_func("gtk_image_new_from_surface",{P},{icon})
case else -- do nothing
end switch
end if
return icon
end if
object theme, icon_info
if string(icon) then
if begins("gtk-",icon) then -- from stock (deprecated)
if size = 0 then size = 6 end if
return gtk_func("gtk_image_new_from_icon_name",{P,I},
{allocate_string(icon,1),size}) -- size is a GTK_ICON_SIZE_ enum;
end if
if file_exists(canonical_path(icon)) then -- from file
icon = canonical_path(icon)
if h = 0 and w = 0 then -- return at natural size;
return gtk_func("gtk_image_new_from_file",{P},
{allocate_string(icon,1)})
else
icon = newPixbuf(icon,w,h,size) -- resize it;
return gtk_func("gtk_image_new_from_pixbuf",{P},{icon})
end if
end if
if file_exists(locate_file(icon)) then -- from file
icon = locate_file(icon)
if h = 0 and w = 0 then -- return at natural size;
return gtk_func("gtk_image_new_from_file",{P},
{allocate_string(icon,1)})
else
icon = newPixbuf(icon,w,h,size) -- resize it;
return gtk_func("gtk_image_new_from_pixbuf",{P},{icon})
end if
end if
if size < 7 then
icon = gtk_func("gtk_image_new_from_icon_name",{P,I},{icon,size})
else
theme = create(GtkIconTheme) -- get current theme;
icon_info = get(theme,"lookup icon",icon,size) -- get icon details;
icon = get(icon_info,"load icon") -- load selected icon;
return create(GtkImage,icon)
end if
end if
return icon
end function
-----------------------------------------------------------------------------------
function setImage(atom img, object icon, integer size=0)
-----------------------------------------------------------------------------------
if size = 0 then
size = get(img,"pixel size")
end if
if string(icon) then
if file_exists(canonical_path(icon)) then -- from file
set(img,"from file",icon)
set(img,"pixel size",size)
return img
end if
if begins("gtk-",icon) then -- from stock (deprecated)
set(img,"from stock",icon)
return img
end if
set(img,"from icon name",icon)
return img
end if
return img
end function
function img_get_icon_name(atom img)
atom name = allocate(8), size = allocate(8)
atom fn = define_proc("gtk_image_get_icon_name",{P,P,P})
c_proc(fn,{img,name,size})
if name > 0 then
return {peek_string(peek4u(name)),peek4u(size)}
else return -1
end if
end function
widget[GdkCursor] = {"gdk_cursor",
{GObject},
{"new",{P,P,P},-routine_id("newCursor")},
{"get_display",{P},P,0,GdkDisplay},
{"get_image",{P},P,0,GdkPixbuf},
{"get_surface",{P,D,D},P,0,CairoSurface_t},
{"get_cursor_type",{P},I},
"GdkCursor"}
-- manages cursor creation from a variety of sources
function newCursor(object a, object b=0, integer c=0)
atom disp = gtk_func("gdk_display_get_default")
if string(a) then
return gtk_func("gdk_cursor_new_from_name",{P,P},{disp,allocate_string(a,1)})
end if
if class_id(a) = GdkPixbuf then
return gtk_func("gdk_cursor_new_from_pixbuf",{P,P,I,I},{disp,a,b,c})
end if
if class_id(a) = CairoSurface_t then
return gtk_func("gdk_cursor_new_from_surface",{P,P,D,D},{disp,a,b,c})
end if
if integer(a) then
return gtk_func("gdk_cursor_new_for_display",{P,I},{disp,a})
end if
end function
widget[GdkWindow] = {"gdk_window",
{GObject},
{"new",{P,P,I},P},
{"set_title",{P,S}},
{"destroy",{P}},
{"get_width",{P},I},
{"get_height",{P},I},
{"get_position",{P,I,I}},
{"get_device_position",{P,P,P,P,P},P,0,GdkWindow},
{"get_device_position_double",{P,P,P,P,P},P,0,GdkWindow},
{"get_origin",{P,I,I}},
{"get_parent",{P},P,0,GdkWindow},
{"get_toplevel",{P},P,0,GdkWindow},
{"get_children",{P},A,0,GList},
{"get_children_with_user_data",{P,P},A,0,GList},
{"peek_children",{P},P,0,GList},
{"get_events",{P},I},
{"set_events",{P,I}},
{"set_icon_name",{P,S}},
{"set_transient_for",{P,P}},
{"get_root_origin",{P,I,I}},
{"get_root_coords",{P,I,I,P,P}},
{"get_frame_extents",{P,P}},
{"set_modal_hint",{P,B}},
{"get_modal_hint",{P},B},
{"set_type_hint",{P,I}},
{"get_type_hint",{P},I},
{"get_window_type",{P},I},
{"get_display",{P},P,0,GdkDisplay},
{"get_screen",{P},P,0,GdkScreen},
{"get_visual",{P},P,0,GdkVisual},
{"show",{P}},
{"show_unraised",{P}},
{"hide",{P}},
{"is_destroyed",{P},B},
{"is_visible",{P},B},
{"is_viewable",{P},B},
{"is_input_only",{P},B},
{"is_shaped",{P},B},
{"set_composited",{P,B}}, -- deprecated 3.16
{"get_composited",{P},B}, -- deprecated 3.16
{"set_opacity",{P,D}},
{"set_cursor",{P,P}},
{"get_cursor",{P},P},
{"get_state",{P},I},
{"withdraw",{P}},
{"iconify",{P}},
{"deiconify",{P}},
{"stick",{P}},
{"unstick",{P}},
{"maximize",{P}},
{"unmaximize",{P}},
{"fullscreen",{P}},
{"unfullscreen",{P}},
{"set_fullscreen_mode",{P,I}},
{"get_fullscreen_mode",{P},I},
{"set_opacity",{P,D}},
{"scroll",{P,I,I}},
{"move_region",{P,P,I,I}},
{"shape_combine_region",{P,P,I,I}},
{"set_child_shapes",{P}},
{"merge_child_shapes",{P}},
{"input_shape_combine_region",{P,P,I,I}},
{"set_child_input_shapes",{P}},
{"merge_child_input_shapes",{P}},
{"get_geometry",{P,I,I,I,I}},
{"set_background_rgba",{P,P}},
{"set_fullscreen_mode",{P,I}},
{"get_fullscreen_mode",{P},I},
{"get_scale_factor",{P},I},
{"set_opaque_region",{P,P}},
{"get_effective_parent",{P},P,0,GdkWindow},
{"get_effective_toplevel",{P},P,0,GdkWindow},
{"beep",{}},
{"focus",{P,I}},
{"restack",{P,P,B}},
{"raise",{P}},
{"lower",{P}},
{"set_keep_above",{P,B}},
{"set_keep_below",{P,B}},
{"reparent",{P,P,I,I}},
{"ensure_native",{P},B},
{"has_native",{P},B},
{"register_dnd",{P}},
{"move",{P,I,I}},
{"scroll",{P,I,I}},
{"resize",{P,I,I}},
{"move_resize",{P,I,I,I,I}},
{"move_region",{P,P,I,I}},
{"begin_resize_drag",{P,I,I,I,I,I}},
{"begin_resize_drag_for_device",{P,I,P,I,I,I,I}},
{"begin_move_drag",{P,I,I,I,I}},
{"begin_move_drag_for_device",{P,P,I,I,I,I}},
{"show_window_menu",{P,P},B},
{"create_gl_context",{P,P},P,0,GdkGLContext}, -- 3.16
{"mark_paint_from_clip",{P,P}}, -- 3.16
{"get_clip_region",{P},P,0,CairoRegion_t},
{"begin_paint_rect",{P,P}},
{"begin_paint_region",{P,P}},
{"end_paint",{P}},
{"set_opaque_region",{P,P}},
{"get_visible_region",{P},P,0,CairoRegion_t},
{"set_invalidate_handler",{P,P}},
{"invalidate_rect",{P,P,B}},
{"invalidate_region",{P,P,B}},
{"invalidate_maybe_recurse",{P,P,P,P}},
{"get_update_area",{P},P,0,CairoRegion_t},
{"freeze_updates",{P}},
{"thaw_updates",{P}},
{"process_all_updates",{P}},
{"process_updates",{P,B}},
{"get_frame_clock",{P},P,0,GdkFrameClock},
{"set_user_data",{P,P}},
{"get_user_data",{P,P}},
{"set_override_redirect",{P,B}},
{"set_accept_focus",{P,B}},
{"get_accept_focus",{P},B},
{"set_focus_on_map",{P,B}},
{"get_focus_on_map",{P},B},
{"add_filter",{P,P,P}},
{"remove_filter",{P,P,P}},
{"set_background_pattern",{P,P}},
{"get_background_pattern",{P},P,0,CairoPattern_t},
{"set_geometry_hints",{P,P,I}},
{"set_functions",{P,I}},
{"get_pass_through",{P},B},
{"set_pass_through",{P,B}},
{"create_gl_context",{P,P},P,0,GdkGLContext},
{"mark_paint_from_clip",{P,P}},
"GdkWindow"}
widget[GdkPixbuf] = {"gdk_pixbuf",
{GObject},
{"new",{P,I,I,I},-routine_id("newPixbuf")},
{"get_from_window",{P,I,I,I,I},P,0,GdkPixbuf},
{"get_from_surface",{P,I,I,I,I},P,0,GdkPixbuf},
{"flip",{P,I},P,0,GdkPixbuf},
{"rotate_simple",{P,I},P,0,GdkPixbuf},
{"scale_simple",{P,I,I,I},P,0,GdkPixbuf},
{"add_alpha",{P,B,I,I,I},P,0,GdkPixbuf},
{"copy_area",{P,I,I,I,I,P,I,I}},
{"apply_embedded_orientation",{P},P,0,GdkPixbuf},
{"fill",{P,P}},
{"get_n_channels",{P},I},
{"get_has_alpha",{P},B},
{"get_colorspace",{P},I},
{"get_bits_per_sample",{P},I},
{"get_pixels_with_length",{P,I},P},
{"get_width",{P},I},
{"get_height",{P},I},
{"get_size",{P},-routine_id("getPixbufSize")},
{"get_rowstride",{P},I},
{"get_byte_length",{P},I},
{"get_option",{P,S},S},
{"saturate_and_pixelate",{P,P,F,B},0,GdkPixbuf},
{"composite_color_simple",{}},-- Cannot implement, use gtk_func if required.
{"save",{P,P,P,P},-routine_id("pb_save")},
{"get_file_info",{P,S},-routine_id("pb_get_file_info")},
{"get_format",{P,S},-routine_id("pb_get_format")},
"GdkPixbuf"}
-- creates a pixbuf from a variety of sources
function newPixbuf(object name, integer w=0, integer h=0, atom ratio=0)
-----------------------------------------------------------------------
atom err = allocate(32,1) err = 0
object path=allocate_string("gtk-missing-image",1)
object pix = 0
if string(name) then
path = canonical_path(locate_file(name))
if file_exists(path) then
ifdef PIXBUF then
display("PIXBUF from file: []",{abbreviate_path(path)},0)
end ifdef
path = allocate_string(path,1)
goto "build"
end if
if has_icon(name) then
path = icon_info(name)
ifdef PIXBUF then
display("PIXBUF from icon: []",{filename(path[3])},0)
end ifdef
if string(path[3]) then
path = allocate_string(path[3],1)
else
path = "!"
end if
goto "build"
else return 0
end if
else
ifdef PIXBUF then
display("PIXBUF from atom: [] []",{name,peek_string(name)},0)
end ifdef
end if -- string name;
label "build"
if h = 0 and w = 0 then -- return at original size;
ifdef PIXBUF then display("Orig size") end ifdef
pix = gtk_func("gdk_pixbuf_new_from_file",{P,P},{path,err})
else -- if one or other dimension given, scale it, otherwise size it;
if w > 0 and h = 0 then h = -1 end if
if w = 0 and h > 0 then w = -1 end if
ifdef PIXBUF then display("\t SCALE []x[] []",{w,h,ratio}) end ifdef
pix = gtk_func("gdk_pixbuf_new_from_file_at_scale",{P,I,I,B,P},{path,w,h,ratio,err})
end if
ifdef PIXBUF_ERR then
if pix = 0 then
display("CAUTION: cannot create pixbuf from []",{peek_string(path)})
end if
end ifdef
return pix
end function
-- save a pixbuf in various formats based on file extension(.png, .jpg, etc)
function pb_save(atom handle, object fn, object ft, object params = 0)
if string(fn) then fn = allocate_string(fn,1) end if
if string(ft) then ft = allocate_string(ft,1) end if
if string(params) then
params = split(params,'=')
for i = 1 to length(params) do
params[i] = allocate_string(params[i],1)
end for
end if
atom err = allocate(8,1) err = 0
if atom(params) then
return gtk_func("gdk_pixbuf_save",{P,P,P,P,P},{handle,fn,ft,err,0})
else
return gtk_func("gdk_pixbuf_save",{P,P,P,P,P,P,P},{handle,fn,ft,err,params[1],params[2],0})
end if
end function
function getPixbufSize(object pb)
return {get(pb,"width"),get(pb,"height")}
end function
function pb_get_file_info(atom pb, object name)
atom w = allocate(8,1), h = allocate(8,1)
object fmt = gtk_func("gdk_pixbuf_get_file_info",{P,P,P},
{name,w,h})
return {fmt,peek4u(w),peek4u(h)}
end function
function pb_get_format(atom pb, object name)
object fmt = pb_get_file_info(pb,name)
return fmt
end function
export function pixbuf_formats()
object fmts = gtk_func("gdk_pixbuf_get_formats")
register(fmts,GSList)
return unpack_gs_str_list(fmts)
end function
widget[GdkPixbufFormat] = {"gdk_pixbuf_format",
{GObject},
{"get_name",{P},S},
{"get_description",{P},S},
{"get_mime_types",{P},A},
-- {"extensions",{P},P}, -- error
{"is_writable",{P},B},
{"is_scalable",{P},B},
{"is_disabled",{P},B},
{"set_disabled",{P,B}},
{"get_license",{P},S},
"GdkPixbufFormat"}
widget[GtkDialog] = {"gtk_dialog",
{GtkWindow,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{},P},
{"run",{P},I},
{"get_action_area",{P},P,0,GtkBox}, -- deprecated 3.12
{"get_content_area",{P},P,0,GtkBox},
{"response",{P,I}},
{"add_button",{P,S,I},P,0,GtkButton},
{"add_action_widget",{P,P,I}},
{"set_default_response",{P,I}},
{"set_response_sensitive",{P,I,B}},
{"get_response_for_widget",{P,P},I},
{"get_widget_for_response",{P,I},P,0,GtkWidget},
{"get_header_bar",{P},P,0,GtkContainer},-- GTK 3.12
"GtkDialog"}
widget[GtkMessageDialog] = {"gtk_message_dialog",
{GtkDialog,GtkWindow,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{P,I,I,I,S,S},P},
{"new_with_markup",{P,I,I,I,S,S},P},
{"set_markup",{P,S}},
{"set_image",{P,P}}, -- deprecated 3.12
{"get_image",{P},P,0,GtkImage}, -- deprecated 3.12
{"format_secondary_text",{P,S,S}},
{"format_secondary_markup",{P,S,S}},
{"get_message_area",{P},P,0,GtkContainer},
"GtkMessageDialog"}
widget[GtkSeparator] = {"gtk_separator",
{GtkWidget,GObject,GtkBuildable,GtkOrientable},
{"new",{I},P},
"GtkSeparator"}
widget[GtkEditable] = {"gtk_editable",
{0},
{"select_region",{P,I,I}},
{"get_selection_bounds",{P,I,I}},
{"insert_text",{P,S,I,I}},
{"delete_text",{P,I,I}},
{"get_chars",{P,I,I},S},
{"cut_clipboard",{P}},
{"copy_clipboard",{P}},
{"paste_clipboard",{P}},
{"delete_selection",{P}},
{"set_position",{P,I}},
{"get_position",{P},I},
{"set_editable",{P,B}},
{"get_editable",{P},B},
"GtkEditable"}
widget[GtkTextIter] = {"gtk_text_iter",
{GObject},
{"get_buffer",{P},P,0,GtkTextBuffer},
{"copy",{P},P,0,GtkTextIter},
{"free",{P}},
{"get_offset",{P},I},
{"get_line",{P},I},
{"get_line_offset",{P},I},
{"get_line_index",{P},I},
{"get_visible_line_index",{P},I},
{"get_visible_line_offset",{P},I},
{"get_char",{P},I},
{"get_slice",{P,P},S},
{"get_text",{P,P},S},
{"get_visible_slice",{P,P},S},
{"get_visible_text",{P,P},S},
{"get_pixbuf",{P},P,0,GdkPixbuf},
{"get_marks",{P},X,0,GSList},
{"get_toggled_tags",{P,B},X,0,GSList},
{"get_child_anchor",{P},P,0,GtkTextChildAnchor},
{"begins_tag",{P,P},B},
{"ends_tag",{P,P},B},
{"toggles_tag",{P,P},B},
{"has_tag",{P,P},B},
{"get_tags",{P},X,0,GSList},
{"editable",{P,B},B},
{"can_insert",{P,B},B},
{"starts_word",{P},B},
{"ends_word",{P},B},
{"inside_word",{P},B},
{"starts_line",{P},B},
{"ends_line",{P},B},
{"starts_sentence",{P},B},
{"ends_sentence",{P},B},
{"inside_sentence",{P},B},
{"is_cursor_position",{P},B},
{"get_chars_in_line",{P},I},
{"get_bytes_in_line",{P},I},
{"get_attributes",{P,P},B},
{"get_language",{P},P,0,PangoLanguage},
{"is_end",{P},B},
{"is_start",{P},B},
{"forward_char",{P},B},
{"backward_char",{P},B},
{"forward_chars",{P,I},B},
{"backward_chars",{P,I},B},
{"forward_line",{P},B},
{"backward_line",{P},B},
{"forward_lines",{P,I},B},
{"backward_lines",{P,I},B},
{"forward_word_ends",{P,I},B},
{"backward_word_starts",{P,I},B},
{"forward_word_ends",{P},B},
{"backward_word_start",{P},B},
{"forward_cursor_position",{P},B},
{"backward_cursor_position",{P},B},
{"forward_cursor_positions",{P,I},B},
{"backward_cursor_positions",{P,I},B},
{"backward_sentence_start",{P},B},
{"backward_sentence_starts",{P,I},B},
{"forward_sentence_end",{P},B},
{"forward_sentence_ends",{P,I},B},
{"forward_visible_word_ends",{P,I},B},
{"backward_visible_word_starts",{P,I},B},
{"forward_visible_word_end",{P},B},
{"backward_visible_word_start",{P},B},
{"forward_visible_cursor_position",{P},B},
{"backward_visible_cursor_position",{P},B},
{"forward_visible_cursor_positions",{P,I},B},
{"backward_visible_cursor_positions",{P,I},B},
{"forward_visible_line",{P},B},
{"backward_visible_line",{P},B},
{"forward_visible_lines",{P,I},B},
{"backward_visible_lines",{P,I},B},
{"set_offset",{P,I}},
{"set_line",{P,I}},
{"set_line_offset",{P,I}},
{"set_line_index",{P,I}},
{"set_visible_line_index",{P,I}},
{"set_visible_line_offset",{P,I}},
{"forward_to_end",{P}},
{"forward_to_line_end",{P},B},
{"forward_to_tag_toggle",{P,P},B},
{"backward_to_tag_toggle",{P,P},B},
{"forward_find_char",{P,P,P,P},B},
{"backward_find_char",{P,P,P,P},B},
{"forward_search",{P,S,I,P,P,P},B},
{"backward_search",{P,S,I,P,P,P},B},
{"equal",{P,P},B},
{"compare",{P,P},I},
{"in_range",{P,P,P},B},
{"order",{P,P}},
{"starts_tag",{P,P},B}, -- 3.20
"GtkTextIter"}
widget[GtkEntry] = {"gtk_entry",
{GtkWidget,GtkEditable,GtkCellEditable,GtkBuildable,GObject},
{"new",{},P},
{"get_buffer",{P},P,0,GtkEntryBuffer},
{"set_buffer",{P,P}},
{"set_text",{P,S}},
{"set_value",{P,D},-routine_id("entry_set_value")}, -- not GTK, a convenience func;
{"get_text",{P},S},
{"get_value",{P},-routine_id("entry_get_value")}, -- not GTK, a convenience func;
{"get_text_length",{P},I},
{"get_text_area",{P,P}},
{"set_visibility",{P,B}},
{"get_visibility",{P},B},
{"set_invisible_char",{P,I}},
{"get_invisible_char",{P},I},
{"unset_invisible_char",{P}},
{"set_max_length",{P,I}},
{"get_max_length",{P},I},
{"set_activates_default",{P,B}},
{"get_activates_default",{P},B},
{"set_has_frame",{P,B}},
{"get_has_frame",{P},B},
{"set_width_chars",{P,I}},
{"get_width_chars",{P},I},
{"set_alignment",{P,F}},
{"get_alignment",{P},F},
{"set_placeholder_text",{P,S}}, -- GTK 3.2+
{"get_placeholder_text",{P},S}, -- GTK 3.2+
{"set_overwrite_mode",{P,B}},
{"get_overwrite_mode",{P},B},
{"get_layout",{P},P,0,PangoLayout},
{"get_layout_offsets",{P,I,I}},
{"set_completion",{P,P}},
{"get_completion",{P},P,0,GtkEntryCompletion},
{"set_progress_fraction",{P,D}},
{"set_progress_pulse_step",{P,D}},
{"progress_pulse",{P}},
{"set_icon_from_stock",{P,I,S}}, -- deprecated 3.10
{"set_icon_from_pixbuf",{P,I,P}},
{"set_icon_from_icon_name",{P,I,S}},
{"set_icon_from_gicon",{P,I,P}},
{"get_icon_storage_type",{P,I},I},
{"get_icon_pixbuf",{P,I},P,0,GdkPixbuf},
{"get_icon_name",{P,I},S},
{"get_icon_area",{P,I,I}},
{"get_icon_gicon",{P,I},P,0,GIcon},
{"set_icon_activatable",{P,I,B}},
{"set_icon_sensitive",{P,I,B}},
{"get_icon_at_pos",{P,I,I},I},
{"set_icon_tooltip_text",{P,I,S}},
{"get_icon_tooltip_text",{P,I},S},
{"set_icon_tooltip_markup",{P,I,S}},
{"get_icon_tooltip_markup",{P,I},S},
{"set_tabs",{P,P}}, -- 3.10
{"get_tabs",{P},P,0,PangoTabArray}, -- 3.10
{"get_max_width_chars",{P},I}, -- 3.12
{"set_max_width_chars",{P,I}}, -- 3.12
{"im_context_filter_keypress",{P,I},B},
{"grab_focus_without_selecting",{P}}, --3.16
"GtkEntry"}
function entry_get_value(atom x) -- retrieve input text as a number;
object txt = get(x,"text")
return to_number(txt)
end function
function entry_set_value(atom x, atom v) -- convert number to text equivalent;
if integer(v) then
set(x,"text",sprintf("%d",v))
else
set(x,"text",sprintf("%2.2f",v))
end if
return 1
end function
widget[GtkSpinButton] = {"gtk_spin_button",
{GtkEntry,GtkWidget,GtkEditable,GtkCellEditable,GtkOrientable,GtkBuildable,GObject},
{"set_adjustment",{P,P}},
{"get_adjustment",{P},P,0,GtkAdjustment},
{"set_digits",{P,I}},
{"get_digits",{P},I},
{"set_range",{P,D,D}},
{"get_range",{P,D,D}},
{"set_value",{P,D}},
{"get_value",{P},-routine_id("getSpinVal")},
{"get_value_as_int",{P},I},
{"set_update_policy",{P,I}},
{"set_numeric",{P,B}},
{"get_numeric",{P},B},
{"set_wrap",{P,B}},
{"get_wrap",{P},B},
{"spin",{P,I,D}},
{"update",{P}},
{"get_increments",{P,D,D}},
{"set_snap_to_ticks",{P,B}},
{"get_snap_to_ticks",{P},B},
{"configure",{P,P,D,I}},
{"new",{D,D,D},-routine_id("newSpinButton")},
"GtkSpinButton"}
-- create a spin button from an ajustment object or from a range of values
function newSpinButton(atom a=0, atom b=0, atom c=0)
----------------------------------------------------
atom sb = 0
if a+b+c = 0 then a = create(GtkAdjustment,0,0,100,1) end if
if class_id(a) = GtkAdjustment then
sb = gtk_func("gtk_spin_button_new",{P,D,I},{a,b,c})
else
sb = gtk_func("gtk_spin_button_new_with_range",{D,D,D},{a,b,c})
end if
return sb
end function
function getSpinVal(atom spin)
------------------------------
object range = get(spin,"range")
atom fn = define_func("gtk_spin_button_get_value",{P},D)
atom val = c_func(fn,{spin})
val = math:ensure_in_range(val,range)
return val
end function
widget[GtkOrientable] = {"gtk_orientable",
{GObject},
{"set_orientation",{P,I}},
{"get_orientation",{P},I},
"GtkOrientable"}
widget[GtkRange] = {"gtk_range",
{GtkWidget,GtkOrientable,GtkBuildable,GObject},
{"set_fill_level",{P,D}},
{"get_fill_level",{P},D},
{"set_restrict_to_fill_level",{P,B}},
{"get_restrict_to_fill_level",{P},B},
{"set_show_fill_level",{P,B}},
{"get_show_fill_level",{P},B},
{"set_adjustment",{P,P}},
{"get_adjustment",{P},P},
{"set_inverted",{P,B}},
{"get_inverted",{P},B},
{"set_value",{P,D}},
{"get_value",{P},D},
{"set_increments",{P,D,D}},
{"set_range",{P,D,D}},
{"set_round_digits",{P,I}},
{"get_round_digits",{P},I},
{"set_lower_stepper_sensitivity",{P,I}},
{"get_lower_stepper_sensitivity",{P},I},
{"set_upper_stepper_sensitivity",{P,I}},
{"get_upper_stepper_sensitivity",{P},I},
{"set_flippable",{P,B}},
{"get_flippable",{P},B},
{"set_min_slider_size",{P,I}},
{"get_min_slider_size",{P},I},
{"get_slider_range",{P,I,I}},
{"set_slider_size_fixed",{P,B}},
{"get_slider_size_fixed",{P},B},
"GtkRange"}
widget[GtkScale] = {"gtk_scale",
{GtkRange,GtkWidget,GtkOrientable,GtkBuildable,GObject},
{"set_digits",{P,I}},
{"get_digits",{P},I},
{"set_draw_value",{P,B}},
{"get_draw_value",{P},B},
{"set_has_origin",{P,B}},
{"get_has_origin",{P},B},
{"set_value_pos",{P,I}},
{"get_value_pos",{P},I},
{"get_layout",{P},P,0,PangoLayout},
{"get_layout_offsets",{P,I,I}},
{"add_mark",{P,D,I,S}},
{"clear_marks",{P}},
{"new",{P,P,P,P},-routine_id("newScale")},
"GtkScale"}
-- create scale from range or adjustment;
function newScale(integer orient, atom min=0, atom max=0, atom step=0)
if min+max+step = 0 then
return gtk_func("gtk_scale_new",{I,P},{orient,0})
end if
if class_id(min) = GtkAdjustment then
return gtk_func("gtk_scale_new",{I,P},{orient,min})
else
return gtk_func("gtk_scale_new_with_range",{I,D,D,D},{orient,min,max,step})
end if
end function
widget[GTimeout] = {"g_timeout",
{0},
{"new",{I,P,P},-routine_id("newTimeout")},
{"add",{I,P,P},-routine_id("newTimeout")},
"GTimeout"}
function newTimeout(integer ms, atom fn, atom data)
return gtk_func("g_timeout_add",{I,P,P},{ms,fn,data})
end function
widget[GIdle] = {"g_idle",
{0},
{"new",{P,P},-routine_id("newIdle")},
{"add",{P,P},-routine_id("newIdle")},
"GIdle"}
function newIdle(atom fn, atom data)
return gtk_func("g_idle_add",{P,P},{fn,data})
end function
widget[GNotification] = {"g_notification",
{0},
{"new",{S},P},
{"set_title",{P,S}},
{"set_body",{P,S}},
{"set_icon",{P,P}},
--{"set_priority",{P,I}}, error
{"set_default_action",{P,S}},
{"add_button",{P,S,S}},
{"add_button_with_target_value",{P,S,S,I}},
{"set_default_action_and_target_value",{P,S,I}},
"GNotification"}
widget[GApplication] = {"g_application",
{0},
{"new",{S,I},P},
{"get_id",{P},S},
{"set_id",{P,S}},
{"id_is_valid",{P,S},B},
{"get_inactivity_timeout",{P},I},
{"set_inactivity_timeout",{P,I}},
{"get_flags",{P},I},
{"set_flags",{P,I}},
{"get_resource_base_path",{P},S},
{"set_resource_base_path",{P,S}},
{"get_dbus_connection",{P},P},
{"get_dbus_object_path",{P},S},
{"get_is_registered",{P},B},
{"get_is_remote",{P},B},
{"register",{P,P,P},B},
{"hold",{P}},
{"release",{P}},
{"quit",{P}},
{"activate",{P}},
{"open",{P,P,I,I}},
{"send_notification",{P,S,P}},
{"withdraw_notification",{P,S}},
{"run",{P,I,P},I},
{"add_main_option_entries",{P,P}},
{"add_option_group",{P,P}},
{"add_main_option",{P,S,S,I,I,S,S}},
{"set_default",{P}},
{"mark_busy",{P}},
{"unmark_busy",{P}},
{"get_is_busy",{P},B},
{"bind_busy_property",{P,P,S}},
{"unbind_busy_property",{P,P,S}},
"GApplication"}
widget[GAppInfo] = {"g_app_info",
{0},
{"get_name",{P},S},
{"get_display_name",{P},S},
{"get_description",{P},S},
{"get_executable",{P},S},
{"get_commandline",{P},S},
{"get_icon",{P},P,0,GIcon},
{"launch",{P,P,P,P},B},
{"supports_files",{P},B},
{"supports_uris",{P},B},
{"launch_uris",{P,P,P,P},B},
{"should_show",{P},B},
{"can_delete",{P},B},
{"delete",{P},B},
{"set_as_default_for_type",{P,S,P},B},
{"set_as_default_for_extension",{P,S,P},B},
{"add_supports_type",{P,S,P},B},
{"can_remove_supports_type",{P},B},
{"remove_supports_type",{P,S,P},B},
{"get_all",{},P,0,GList},
"GAppInfo"}
widget[GFile] = {"g_file",
{GObject},
{"new",{P},-routine_id("newGFile")},
{"get_parse_name",{P},S},
{"parse_name",{S},P},
{"equal",{P,P},B},
{"get_basename",{P},S},
{"get_path",{P},S},
{"get_uri",{P},S},
{"get_parse_name",{P},S},
{"get_parent",{P},P,0,GFile},
{"has_parent",{P,P},B},
{"get_child",{P,S},P,0,GFile},
{"get_child_for_display_name",{P,S,P},P,0,GFile},
{"has_prefix",{P,P},B},
{"get_relative_path",{P,P},S},
{"resolve_relative_path",{P,S},P,0,GFile},
{"is_native",{P},B},
{"has_uri_scheme",{P,S},B},
{"get_uri_scheme",{P},S},
{"read",{P,P,P},P,0,GFileInputStream},
"GFile"}
-- create a GFile from a path or uri
function newGFile(object s)
if file_exists(canonical_path(locate_file(s))) then
return gtk_func("g_file_new_for_path",{P},
{allocate_string(canonical_path(locate_file(s)),1)})
else
return gtk_func("g_file_new_for_uri",{P},
{allocate_string(s,1)})
end if
return 0
end function
widget[GIcon] = {"g_icon",
{GObject},
{"hash",{P},I},
{"equal",{P,P},B},
{"to_string",{P},S},
{"new_for_string",{S,P},P},
{"new",{S},-routine_id("newGIcon")},
{"serialize",{P},P},
{"deserialize",{P},P,0,GIcon},
"GIcon"}
function newGIcon(object s)
if string(s) then s = allocate_string(s,1) end if
return gtk_func("g_icon_new_for_string",{P,P},{s,0})
end function
widget[GFileIcon] = {"g_file_icon",
{GIcon,GObject},
{"new",{P},P},
{"get_file",{P},P},
"GFileIcon"}
widget[GFileInfo] = {"g_file_info",
{GObject},
{"new",{},P},
{"get_name",{P},S},
{"get_display_name",{P},S},
{"get_edit_name",{P},S},
{"get_icon",{P},P,0,GIcon},
{"get_symbolic_icon",{P},P,0,GIcon},
{"get_content_type",{P},S},
{"get_size",{P},I},
{"get_modification_time",{P,P}},
{"get_symlink_target",{P},S},
{"get_etag",{P},S},
{"get_sort_order",{P},I},
{"get_deletion_date",{P},P,0,GDateTime},
{"set_is_hidden",{P,B}},
{"set_is_symlink",{P,B}},
{"set_name",{P,S}},
{"set_display_name",{P,S}},
{"set_edit_name",{P,S}},
{"set_icon",{P,P}},
{"set_symbolic_icon",{P,P}},
{"set_content_type",{P,S}},
{"set_size",{P,I}},
"GFileInfo"}
widget[GList] = {"g_list",
{GObject},
{"new",{},-routine_id("newGList")},
{"append",{P,P},P},
{"length",{P},I},
{"nth_data",{P,I},P},
"GList"}
function newGList()
atom x = allocate(64) x = 0 -- keep;
return x
end function
widget[GSList] = {"g_slist",
{GObject},
{"length",{P},I},
"GSList"}
object temp_list
export function unpack_gs_str_list(atom gs)
if gs = 0 then return 1 end if
atom fn = call_back(routine_id("gs_str_each"))
temp_list = {}
gtk_proc("g_slist_foreach",{P,P,P},{gs,fn,0})
return temp_list
end function
function gs_str_each(object x)
if x > 0 then
temp_list = append(temp_list,peek_string(x))
end if
return 1
end function
export function unpack_gs_atom_list(object gs)
temp_list = {}
atom fn = call_back(routine_id("gs_atom_each"))
gtk_proc("g_slist_foreach",{P,P,P},{gs,fn,0})
return temp_list
end function
function gs_atom_each(object x)
temp_list = append(temp_list,x)
return 1
end function
widget[GdkDisplay] = {"gdk_display",
{GObject},
{"new",{},-routine_id("newGdkDisplay")}, -- alias get_default;
{"open",{S},P,0,GdkDisplay},
{"get_name",{P},S},
{"get_n_screens",{P},I},
{"get_screen",{P,I},P,0,GdkScreen},
{"get_default_screen",{P},P,0,GdkScreen},
{"get_device_manager",{P},P,0,GdkDeviceManager},
{"device_is_grabbed",{P,P},B},
{"beep",{P}},
{"sync",{P}},
{"flush",{P}},
{"close",{P}},
{"is_closed",{P},B},
{"get_event",{P},P,0,GdkEvent},
{"peek_event",{P},P,0,GdkEvent},
{"put_event",{P,P}},
{"has_pending",{P},B},
{"set_double_click_time",{P,I}},
{"set_double_click_distance",{P,I}},
{"supports_cursor_color",{P},B},
{"supports_cursor_alpha",{P},B},
{"get_default_cursor_size",{P},I},
{"get_maximal_cursor_size",{P,I,I}},
{"get_default_group",{P},P,0,GdkWindow},
{"supports_selection_notification",{P},B},
{"request_selection_notification",{P,P},B},
{"supports_clipboard_persistence",{P},B},
{"store_clipboard",{P,P,I,P,I}},
{"supports_shapes",{P},B},
{"supports_input_shapes",{P},B},
{"supports_composite",{P},B}, -- deprecated 3.16
{"get_app_launch_context",{P},P,0,GtkAppLaunchContext},
{"notify_startup_complete",{P,S}},
"GdkDisplay"}
function newGdkDisplay() -- alias;
return gtk_func("gdk_display_get_default",{})
end function
widget[GdkDevice] = {"gdk_device",
{GObject},
{"get_name",{P},S},
{"get_device_type",{P},I},
{"get_display",{P},P,0,GdkDisplay},
{"get_has_cursor",{P},B},
{"get_n_axes",{P},I},
{"get_n_keys",{P},I},
{"warp",{P,P,I,I}},
{"grab",{P,P,I,B,I,P,P},I},
{"ungrab",{P,P}},
{"get_state",{P,P,D,P}},
{"get_position",{P,P,I,I}},
{"get_position_double",{P,P,D,D}},
{"get_window_at_position",{P,I,I},P,0,GdkWindow},
{"get_window_at_position_double",{P,D,D},P,0,GdkWindow},
{"get_history",{P,P,P,P,P,I},B},
{"free_history",{P,I}},
{"get_vendor_id",{P},S},
{"get_product_id",{P},S},
{"get_source",{P},P,0,GdkInputSource},
{"set_mode",{P,I},B},
{"get_mode",{P},I},
{"set_key",{P,I,I,I}},
{"get_key",{P,I,I,I},B},
{"get_axis",{P,D,I,D},B},
{"list_axes",{P},A,0,GList},
{"get_axis_value",{P,D,P,D},B},
{"get_last_event_window",{P},P,0,GdkWindow},
{"set_axis_use",{P,I,I}},
{"get_axis_use",{P,I},I},
{"get_associated_device",{P},P,0,GdkDevice},
{"list_slave_devices",{P},A,0,GList},
{"get_position",{P,P,I,I}},
"GdkDevice"}
widget[GdkScreen] = {"gdk_screen",
{GdkDevice,GObject},
{"new",{},-routine_id("newGdkScreen")}, -- alias get_default;
{"get_system_visual",{P},P,0,GdkVisual},
{"get_rgba_visual",{P},P,0,GdkVisual},
{"is_composited",{P},B},
{"get_root_window",{P},P,0,GdkWindow},
{"get_display",{P},P,0,GdkDisplay},
{"get_number",{P},I},
{"get_width",{P},I},
{"get_height",{P},I},
{"get_width_mm",{P},I},
{"get_height_mm",{P},I},
{"list_visuals",{P},P,0,GList},
{"get_toplevel_windows",{P},P,0,GList},
{"make_display_name",{P},S},
{"get_n_monitors",{P},I},
{"get_primary_monitor",{P},I},
{"get_monitor_geometry",{P,I,P}},
{"get_monitor_workarea",{P,I,P}},
{"get_monitor_at_point",{P,I,I},I},
{"get_monitor_at_window",{P,P},I},
{"get_monitor_height_mm",{P,I},I},
{"get_monitor_width_mm",{P,I},I},
{"get_monitor_plug_name",{P,I},S},
{"get_setting",{P,S,P},B},
{"get_font_options",{P},P,0,CairoFontOptions},
{"get_resolution",{P},D},
{"set_resolution",{P,D}},
{"get_active_window",{P},P,0,GdkWindow},
{"get_window_stack",{P},P,0,GList},
"GdkScreen"}
function newGdkScreen() -- alias;
return gtk_func("gdk_screen_get_default",{})
end function
widget[GdkVisual] = {"gdk_visual",
{GObject},
"GdkVisual"}
widget[GThemedIcon] = {"g_themed_icon",
{GIcon,GObject},
{"new",{S},P},
{"new_with_default_fallbacks",{S},P},
{"get_names",{P},P},
"GThemedIcon"}
widget[GtkThemedIcon] = {"gtk_themed_icon",
{GObject},
"GtkThemedIcon"}
widget[GEmblem] = {"g_emblem",
{GObject},
{"new",{P},P},
{"get_icon",{P},P,0,GIcon},
"GEmblem"}
widget[GEmblemedIcon] = {"g_emblemed_icon",
{GIcon,GObject},
{"new",{P,P},P},
"GEmblemedIcon"}
widget[GdkDeviceManager] = {"gdk_device_manager",
{GObject},
{"new",{P},-routine_id("newDeviceManager")},
{"get_display",{P},P,0,GdkDisplay},
{"list_devices",{P,I},X,0,GList},
{"get_client_pointer",{P},P,0,GdkDevice},
"GdkDeviceManager"}
function newDeviceManager(atom disp=0)
if disp = 0 then
disp = gtk_func("gdk_display_get_default")
end if
return gtk_func("gdk_display_get_device_manager",{P},{disp})
end function
widget[GtkAppChooser] = {"gtk_app_chooser",
{GtkWidget},
{"get_app_info",{P},P,0,GAppInfo},
{"get_content_type",{P},S},
{"refresh",{P}},
"GtkAppChooser"}
widget[GtkAppChooserButton] = {"gtk_app_chooser_button",
{GtkComboBox,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GtkCellLayout,GtkCellEditable,GObject},
{"new",{S},P},
{"append_custom_item",{P,S,S,P}},
{"append_separator",{P}},
{"set_active_custom_item",{P,S}},
{"set_show_default_item",{P,B}},
{"get_show_default_item",{P},B},
{"set_show_dialog_item",{P,B}},
{"get_show_dialog_item",{P},B},
{"set_heading",{P,S}},
{"get_heading",{P},S},
"GtkAppChooserButton"}
widget[GMenu] = {"g_menu",
{GObject},
{"new",{},P},
{"append",{P,S,S}},
"GMenu"}
widget[GSettings] = {"g_settings",
{GObject},
{"new",{S},P},
{"set_value",{P,S,P},B},
{"get_value",{P},P},
{"get_user_value",{P,S},P},
"GSettings"}
widget[GtkApplication] = {"gtk_application",
{GApplication,GObject},
{"new",{S,I},-routine_id("newApplication")},
{"add_window",{P,P}},
{"remove_window",{P,P}},
{"get_windows",{P},A,0,GList},
{"get_window_by_id",{P,I},P,0,GtkWindow},
{"get_active_window",{P},P,0,GtkWindow},
{"inhibit",{P,P,I,S},I},
{"uninhibit",{P,I}},
{"is_inhibited",{P,I},B},
{"get_app_menu",{P},P,0,GMenuModel},
{"set_app_menu",{P,P}},
{"get_menubar",{P},P,0,GMenuModel},
{"set_menubar",{P,P}},
{"add_accelerator",{P,S,S,P}},
{"remove_accelerator",{P,S,P}},
{"run",{P},-routine_id("app_run")},
{"activate",{P},-routine_id("app_activate")},
{"get_accels_for_action",{P,S},V}, -- 3.12
{"set_accels_for_action",{P,S,S}}, -- 3.12
{"list_action_descriptions",{P},V},
{"get_actions_for_accel",{P,S},V}, -- 3.14
{"get_menu_by_id",{P,S},P,0,GMenu}, -- 3.14
{"prefers_app_menu",{},B}, -- 3.14
"GtkApplication"}
function app_activate(object x)
gtk_proc("g_application_activate",{P},{x})
return 1
end function
function app_run(object x)
gtk_proc("g_application_run",{P,I,P},{x,0,0})
return 1
end function
function newApplication(object id, object flags)
if string(id) then id = allocate_string(id,1) end if
if gtk_func("g_application_id_is_valid",{P},{id}) then
return gtk_func("gtk_application_new",{P,I},{id,flags})
else
crash("Error: invalid application id!")
end if
return 0
end function
widget[GtkApplicationWindow] = {"gtk_application_window",
{GtkWindow,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{P},P},
{"set_show_menubar",{P,B}},
{"get_show_menubar",{P},B},
{"set_help_overlay",{P,P}}, -- 3.20
{"get_help_overlay",{P},P,0,GtkShortcutsWindow}, -- 3.20
{"get_id",{P},I},
"GtkApplicationWindow"}
widget[GtkActionable] = {"gtk_actionable",
{GtkWidget},
{"get_action_name",{P},S},
{"set_action_name",{P,S}},
{"get_action_target_value",{P},P},
{"set_action_target_value",{P,P}},
{"set_action_target",{P,S,P}},
{"set_detailed_action_name",{P,S}},
"GtkActionable"}
-- Soon to be deprecated, but still used internally by Glade;
widget[GtkAlignment] = {"gtk_alignment",
{GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{F,F,F,F},P},
{"set",{P,F,F,F,F}},
{"get_padding",{P,I,I,I,I}},
{"set_padding",{P,I,I,I,I}},
"GtkAlignment"}
widget[GtkAppLaunchContext] = {"gdk_app_launch_context",
{GdkAppLaunchContext,GObject},
{"set_screen",{P,P}},
{"set_desktop",{P,I}},
{"set_timestamp",{P,I}},
{"set_icon",{P,P}},
{"set_icon_name",{P,S}},
"GtkAppLaunchContext"}
widget[GtkAspectFrame] = {"gtk_aspect_frame",
{GtkFrame,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{S,F,F,F,B},P},
{"set",{P,F,F,F,B}},
"GtkAspectFrame"}
widget[GtkAssistant] = {"gtk_assistant",
{GtkWindow,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{},P},
{"set_current_page",{P,I}},
{"get_current_page",{P},I},
{"get_n_pages",{P},I},
{"get_nth_page",{P,I},P,0,GtkWidget},
{"prepend_page",{P,P},I},
{"append_page",{P,P},I},
{"insert_page",{P,P,I},I},
{"remove_page",{P,I}},
{"set_forward_page_func",{P,P,P,P}},
{"set_page_type",{P,P,P}},
{"get_page_type",{P,P},I},
{"set_page_title",{P,P,S}},
{"get_page_title",{P,P},S},
{"set_page_complete",{P,P,B}},
{"get_page_complete",{P,P},B},
{"add_action_widget",{P,P}},
{"remove_action_widget",{P,P}},
{"update_buttons_state",{P}},
{"commit",{P}},
{"next_page",{P}},
{"previous_page",{P}},
{"get_page_has_padding",{P,P},B}, -- 3.18
{"set_page_has_padding",{P,P,B}}, -- 3.18
"GtkAssistant"}
widget[GtkDrag] = {"gtk_drag",
{0},
{"get_data",{P,P,P,P}},
{"get_source_widget",{P},P,0,GtkWidget},
{"highlight",{P}},
{"unhighlight",{P}},
{"begin_with_coordinates",{P,P,P,I,P,I,I},P},
{"finish",{P,B,B,P}},
{"set_icon_widget",{P,P,I,I}},
{"set_icon_pixbuf",{P,P,I,I}},
{"set_icon_surface",{P,P}},
{"set_icon_name",{P,P,I,I}},
{"set_icon_gicon",{P,P,I,I}},
{"set_icon_default",{P}},
{"check_threshold",{P,I,I,I,I},B},
{"cancel",{P}}, -- 3.16
"GtkDrag"}
widget[GtkDragSource] = {"gtk_drag_source",
{GtkDrag},
{"set",{P,I,P,I,I}},
{"set_icon_pixbuf",{P,P}},
{"set_icon_name",{P,S}},
{"set_icon_gicon",{P,P}},
{"unset",{P}},
{"set_target_list",{P,P}},
{"get_target_list",{P},P,0,GtkTargetList},
{"add_text_targets",{P}},
{"add_image_targets",{P}},
{"add_uri_targets",{P}},
"GtkDragSource"}
widget[GtkDragDest] = {"gtk_drag_dest",
{GtkDrag},
{"set",{P,I,P,I,I}},
{"set_proxy",{P,P,I,B}},
{"unset",{P}},
{"find_target",{P,P,P},P},
{"get_target_list",{P},P,0,GtkTargetList},
{"set_target_list",{P,P}},
{"add_text_targets",{P}},
{"add_image_targets",{P}},
{"add_uri_targets",{P}},
{"set_track_motion",{P,B}},
{"get_track_motion",{P},B},
"GtkDragDest"}
widget[GtkCssProvider] = {"gtk_css_provider",
{GObject},
{"new",{P},-routine_id("new_css_provider")},
{"get_default",{},P,0,GtkCssProvider},
{"get_named",{S,S},P,0,GtkCssProvider},
{"load_from_data",{P,S,I,P},B},
{"load_from_file",{P,S,P},B},
{"load_from_path",{P,S,P},B},
{"load_from_resource",{P,S}}, -- 3.16
{"to_string",{P},S},
"GtkCssProvider"}
function new_css_provider(object name=0)
atom provider = gtk_func("gtk_css_provider_get_default")
atom style = create(GtkStyleContext)
atom screen = get(style,"screen")
atom err = allocate(64,1) err = 0
register(provider,GtkCssProvider)
if atom(name) then
set(style,"add provider for screen",screen,provider,800)
return provider
end if
if file_exists(canonical_path(locate_file(name))) then
if gtk_func("gtk_css_provider_load_from_path",{P,P,P},
{provider,allocate_string(canonical_path(locate_file(name)),1),err}) then
set(style,"add provider for screen",screen,provider,800)
return provider
else
printf(1,"Error finding or parsing css from path: %s \n",
{canonical_path(locate_file(name))})
end if
end if
if string(name) then
integer len = length(name)
name = allocate_string(name,1)
if gtk_func("gtk_css_provider_load_from_data",{P,P,I,P},{provider,name,len,err}) then
set(style,"add provider for screen",screen,provider,800)
end if
end if
return provider
end function
widget[GtkCssSection] = {"gtk_css_section",
{GObject},
{"get_end_line",{P},I},
{"get_end_position",{P},I},
{"get_file",{P},P,0,GFile},
{"get_parent",{P},P,0,GtkCssSection},
{"get_section_type",{P},I},
{"get_start_line",{P},I},
{"get_start_position",{P},I},
"GtkCssSection"}
widget[GtkStatusIcon] = {"gtk_status_icon", -- deprecated 3.14
{GObject},
{"new",{},P,0,GObject},
{"new_from_pixbuf",{P},P},
{"new_from_file",{S},P},
{"new_from_icon_name",{S},P},
{"new_from_gicon",{P},P},
{"set_from_pixbuf",{P,P}},
{"set_from_file",{P,S}},
{"set_from_icon_name",{P,S}},
{"set_from_gicon",{P,P}},
{"get_storage_type",{P},I},
{"get_pixbuf",{P},P,0,GdkPixbuf},
{"get_icon_name",{P},S},
{"get_gicon",{P},P},
{"get_size",{P},I},
{"set_screen",{P,P}},
{"get_screen",{P},P,0,GdkScreen},
{"set_tooltip_text",{P,S}},
{"get_tooltip_text",{P},S},
{"set_tooltip_markup",{P,S}},
{"get_tooltip_markup",{P},S},
{"set_has_tooltip",{P,B}},
{"get_has_tooltip",{P},P},
{"set_title",{P,S}},
{"get_title",{P},S},
{"set_name",{P,S}},
{"set_visible",{P,B}},
{"get_visible",{P},B},
{"is_embedded",{P},B},
{"get_geometry",{P,P,P,I},B},
{"get_x11_window_id",{P},I},
{"position_menu",{P,P,I,I,B},-routine_id("si_position_menu")},
"GtkStatusIcon"}
function si_position_menu(atom stat, atom menu, integer x, integer y, integer p)
atom fn = define_proc("gtk_status_icon_position_menu",{P,I,I,I,P})
c_proc(fn,{menu,x,y,p,stat}) -- menu and status_icon params swapped;
return 1
end function
widget[GtkOffscreenWindow] = {"gtk_offscreen_window",
{GtkWindow,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{},P},
{"get_surface",{P},P,0,CairoSurface_t},
{"get_pixbuf",{P},P,0,GdkPixbuf},
"GtkOffscreenWindow"}
widget[GtkComboBox] = {"gtk_combo_box",
{GtkBin,GtkContainer,GtkWidget,GtkCellLayout,GtkCellEditable,GtkBuildable,GObject},
{"new",{P},-routine_id("newComboBox")},
{"set_wrap_width",{P,I}},
{"get_wrap_width",{P},I},
{"set_row_span_column",{P,I}},
{"get_row_span_column",{P},I},
{"set_column_span_column",{P,I}},
{"get_column_span_column",{P},I},
{"set_active",{P,I}},
{"get_active",{P},I},
{"set_id_column",{P,I}},
{"get_id_column",{P},I},
{"set_active_id",{P,S},B},
{"get_active_id",{P},S},
{"set_model",{P,P}},
{"get_model",{P},P,0,GtkTreeModel},
{"popup_for_device",{P,P}},
{"popup",{P}},
{"popdown",{P}},
{"set_row_separator_func",{P,P,P,P}},
{"get_row_separator_func",{P},P},
{"set_add_tearoffs",{P,B}}, -- deprecated 3.10
{"get_add_tearoffs",{P},B}, -- deprecated 3.10
{"set_title",{P,S}}, -- deprecated 3.10
{"get_title",{P},S}, -- deprecated 3.10
{"set_focus_on_click",{P,B}},
{"get_focus_on_click",{P},B},
{"set_button_sensitivity",{P,I}},
{"get_button_sensitivity",{P},I},
{"get_has_entry",{P},B},
{"set_entry_text_column",{P,I}},
{"get_entry_text_column",{P},I},
{"set_popup_fixed_width",{P,B}},
{"get_popup_fixed_width",{P},B},
{"set_activates_default",{P,B},-routine_id("combo_set_activates_default")},
{"get_entry",{P},-routine_id("combo_get_entry")},
"GtkComboBox"}
-- create a combo box either empty or from a model
function newComboBox(object x=0)
if x = 0 then
return gtk_func("gtk_combo_box_new",{},{})
end if
if class_id(x) = GtkListStore then
return gtk_func("gtk_combo_box_new_with_model",{P},{x})
end if
end function
function combo_get_entry(atom box)
atom x = get(box,"child")
register(x,GtkEntry)
return x
end function
function combo_set_activates_default(atom box, boolean z)
atom x = get(box,"child")
register(x,GtkEntry)
set(x,"property","activates-default",z)
return 1
end function
widget[GtkComboBoxText] = {"gtk_combo_box_text",
{GtkCellLayout,GtkCellEditable,GtkComboBox,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{},P},
{"new_with_entry",{},P},
{"append",{P,S,S}},
{"prepend",{P,S,S}},
{"insert",{P,I,S,S}},
{"append_text",{P,S}},
{"prepend_text",{P,S}},
{"insert_text",{P,I,S}},
{"remove",{P,I}},
{"remove_all",{P}},
{"get_active_text",{P},S},
"GtkComboBoxText"}
widget[GtkComboBoxEntry] = {"gtk_combo_box_text",
{GtkComboBoxText,GtkComboBox,GtkBin,GtkContainer,GtkWidget,GObject},
{"new",{},-routine_id("new_combo_box_entry")},
"GtkComboBoxEntry"}
function new_combo_box_entry() -- alias;
return gtk_func("gtk_combo_box_text_new_with_entry",{},{})
end function
widget[GtkFrame] = {"gtk_frame",
{GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{S},P},
{"set_label",{P,S}},
{"get_label",{P},S},
{"set_label_align",{P,F,F}},
{"get_label_align",{P,F,F}},
{"set_label_widget",{P,P}},
{"get_label_widget",{P},P,0,GtkWidget},
{"set_shadow_type",{P,I}},
{"get_shadow_type",{P},I},
"GtkFrame"}
widget[GtkModelButton] = {"gtk_model_button", -- new in 3.16
{GtkButton,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GtkActionable,GObject},
{"new",{},P},
"GtkModelButton"}
widget[GtkButton] = {"gtk_button",
{GtkBin,GtkContainer,GtkWidget,GtkBuildable,GtkActionable,GObject},
{"new",{P},-routine_id("newButton")},
{"new_from_icon_name",{S,I},P,0,GtkWidget}, -- 3.10
{"set_relief",{P,I}},
{"get_relief",{P},I},
{"set_label",{P,S}},
{"get_label",{P},S},
{"set_use_underline",{P,B}},
{"get_use_underline",{P},B},
{"set_focus_on_click",{P,B}},
{"get_focus_on_click",{P},B},
{"set_alignment",{P,F,F}}, -- deprecated 3.14
{"get_alignment",{P,F,F}}, -- deprecated 3.15
{"set_image",{P,P},-routine_id("setBtnImage")},
{"get_image",{P},P,0,GtkImage},
{"set_image_position",{P,I}},
{"get_image_position",{P},I},
{"set_always_show_image",{P,B}}, -- GTK 3.6+
{"get_always_show_image",{P},B}, -- GTK 3.6+
{"get_event_window",{P},P,0,GdkWindow},
"GtkButton"}
function setBtnImage(atom btn, object img)
------------------------------------------
if class_id(img) = GdkPixbuf then
img = create(GtkImage,img)
end if
if string(img) then
if file_exists(canonical_path(img)) then
img = canonical_path(img)
elsif file_exists(canonical_path("~" & img)) then
img = canonical_path("~" & img)
end if
img = create(GdkPixbuf,img,20,20,1)
img = create(GtkImage,img)
end if
if atom(img) then
gtk_proc("gtk_button_set_image",{P,P},{btn,img})
end if
return 1
end function
-- handles creation of buttons with icons from various sources;
-- this function modified greatly from earlier versions, in order
-- to circumvent the misguided idea that buttons, menus, etc. should not have
-- icons (even though window managers have settings to show or hide these
-- icons as the USER prefers)
function newButton(object cap = 0)
----------------------------------
atom btn = 0
object tmp, t1, box, lbl = 0, icon = 0
if atom(cap) then
if cap = 0 then -- blank button;
btn = gtk_func("gtk_button_new",{})
register(btn,GtkButton)
return btn
else
btn = gtk_func("gtk_button_new",{})
register(btn,GtkButton)
set(btn,"use underline",TRUE)
if class_id(cap) = GdkPixbuf then -- convert to image;
cap = create(GtkImage,cap)
end if
if class_id(cap) = GtkImage then
set(btn,"image",cap) -- add image to btn
set(btn,"always show image",BTN_SHOW_IMG)
end if
return btn
end if
end if
if string(cap) then
if match("#",cap) = 0 then
btn = gtk_func("gtk_button_new_from_stock",{P},{allocate_string(cap)})
register(btn,GtkButton)
set(btn,"always show image",BTN_SHOW_IMG)
set(btn,"use underline",TRUE)
return btn
end if
tmp = split(cap,'#')
btn = gtk_func("gtk_button_new_with_mnemonic",{P},{allocate_string(tmp[2],1)})
register(btn,GtkButton)
set(btn,"use underline",TRUE)
t1 = canonical_path(locate_file(tmp[1]))
if match("gtk-",cap) = 1 then
btn = gtk_func("gtk_button_new")
register(btn,GtkButton)
box = create(GtkBox,0,5)
add(btn,box)
icon = create(GtkImage,tmp[1],ceil(BTN_ICON_SIZE/10))
if icon > 0 then add(box,icon) end if
if length(tmp[2]) > 0 then
lbl = gtk_func("gtk_label_new_with_mnemonic",{P},{allocate_string(tmp[2])})
register(lbl,GtkLabel)
set(lbl,"font",sprintf("%d",BTN_TEXT_SIZE))
add(box,lbl)
end if
set(btn,"always show image",BTN_SHOW_IMG)
set(btn,"use underline",TRUE)
return btn
elsif file_exists(t1) then
icon = create(GdkPixbuf,t1,BTN_ICON_SIZE,0,1)
else
icon = create(GtkImage,tmp[1],BTN_ICON_SIZE,0,1)
end if
set(btn,"image",icon)
set(btn,"always show image",BTN_SHOW_IMG)
set(btn,"use underline",TRUE)
return btn
end if
btn = gtk_func("gtk_button_new",{})
register(btn,GtkButton)
return btn
end function
widget[GtkToggleButton] = {"gtk_toggle_button",
{GtkButton,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GtkActionable,GObject},
{"new",{P},-routine_id("newToggleButton")},
{"new_with_label",{S},P},
{"new_with_mnemonic",{S},P},
{"set_mode",{P,B}},
{"get_mode",{P},B},
{"toggled",{P}},
{"set_active",{P,B}},
{"get_active",{P},B},
{"set_inconsistent",{P,B}},
{"get_inconsistent",{P},B},
"GtkToggleButton"}
function newToggleButton(object cap = 0)
atom btn = 0
object tmp, t1, icon = 0
if atom(cap) then
if cap = 0 then -- blank button;
btn = gtk_func("gtk_toggle_button_new",{})
register(btn,GtkToggleButton)
return btn
else
btn = gtk_func("gtk_toggle_button_new",{})
register(btn,GtkToggleButton)
if class_id(cap) = GdkPixbuf then -- convert to image;
cap = create(GtkImage,cap)
end if
if class_id(cap) = GtkImage then
set(btn,"image",cap) -- add image to btn
set(btn,"always show image",BTN_SHOW_IMG)
end if
return btn
end if
end if
if string(cap) then
if match("#",cap) = 0 then
btn = gtk_func("gtk_toggle_button_new_with_mnemonic",{P},{allocate_string(cap)})
register(btn,GtkToggleButton)
return btn
end if
tmp = split(cap,'#')
btn = gtk_func("gtk_toggle_button_new_with_mnemonic",{P},{allocate_string(tmp[2],1)})
register(btn,GtkToggleButton)
t1 = canonical_path(locate_file(tmp[1]))
if match("gtk-",cap) = 1 then
icon = create(GtkImage,tmp[1],ceil(BTN_ICON_SIZE/5))
elsif file_exists(t1) then
icon = create(GdkPixbuf,t1,BTN_ICON_SIZE,0,1)
else
icon = create(GtkImage,tmp[1],BTN_ICON_SIZE,0,1)
end if
set(btn,"image",icon)
set(btn,"always show image",BTN_SHOW_IMG)
return btn
end if
btn = gtk_func("gtk_toggle_button_new",{})
register(btn,GtkToggleButton)
return btn
end function
widget[GtkCheckButton] = {"gtk_check_button",
{GtkToggleButton,GtkButton,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GtkActionable,GObject},
{"new",{P},-routine_id("newCheckButton")},
{"new_with_label",{S},P,0,GtkCheckButton},
{"new_with_mnemonic",{S},P,0,GtkCheckButton},
"GtkCheckButton"}
function newCheckButton(object cap = 0)
atom btn = 0
object tmp, t1, icon = 0
if atom(cap) then
if cap = 0 then -- blank button;
btn = gtk_func("gtk_check_button_new",{})
register(btn,GtkCheckButton)
return btn
else
btn = gtk_func("gtk_check_button_new",{})
register(btn,GtkCheckButton)
if class_id(cap) = GdkPixbuf then -- convert to image;
cap = create(GtkImage,cap)
end if
if class_id(cap) = GtkImage then
set(btn,"image",cap) -- add image to btn
set(btn,"always show image",BTN_SHOW_IMG)
end if
return btn
end if
end if
if string(cap) then
if match("#",cap) = 0 then
btn = gtk_func("gtk_check_button_new_with_mnemonic",{P},{allocate_string(cap)})
register(btn,GtkCheckButton)
return btn
end if
tmp = split(cap,'#')
btn = gtk_func("gtk_check_button_new_with_mnemonic",{P},{allocate_string(tmp[2],1)})
register(btn,GtkCheckButton)
t1 = canonical_path(locate_file(tmp[1]))
if match("gtk-",cap) = 1 then
icon = create(GtkImage,tmp[1],ceil(BTN_ICON_SIZE/5))
elsif file_exists(t1) then
icon = create(GdkPixbuf,t1,BTN_ICON_SIZE,0,1)
else
icon = create(GtkImage,tmp[1],BTN_ICON_SIZE,0,1)
end if
set(btn,"image",icon)
set(btn,"always show image",BTN_SHOW_IMG)
return btn
end if
btn = gtk_func("gtk_check_button_new",{})
register(btn,GtkCheckButton)
return btn
end function
widget[GtkRadioButton] = {"gtk_radio_button",
{GtkCheckButton,GtkToggleButton,GtkButton,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GtkActionable,GObject},
{"new",{P,P},-routine_id("newRadioButton")},
{"set_group",{P,P}},
{"get_group",{P},P},
{"join_group",{P,P}},
"GtkRadioButton"}
function newRadioButton(atom group=0, object cap = 0)
atom btn = 0
object tmp, t1, icon = 0
if atom(cap) then
if cap = 0 then -- blank button;
btn = gtk_func("gtk_radio_button_new",{P},{group})
register(btn,GtkRadioButton)
return btn
else
btn = gtk_func("gtk_radio_button_new",{P},{group})
register(btn,GtkRadioButton)
if class_id(cap) = GdkPixbuf then -- convert to image;
cap = create(GtkImage,cap)
end if
if class_id(cap) = GtkImage then
set(btn,"image",cap) -- add image to btn
set(btn,"always show image",BTN_SHOW_IMG)
end if
return btn
end if
end if
if string(cap) then
if match("#",cap) = 0 then
btn = gtk_func("gtk_radio_button_new_with_mnemonic_from_widget",{P,P},{group,cap})
register(btn,GtkRadioButton)
return btn
end if
tmp = split(cap,'#')
btn = gtk_func("gtk_radio_button_new_with_mnemonic_from_widget",{P,P},{group,allocate_string(tmp[2],1)})
register(btn,GtkRadioButton)
t1 = canonical_path(locate_file(tmp[1]))
if match("gtk-",cap) = 1 then
icon = create(GtkImage,tmp[1],ceil(BTN_ICON_SIZE/5))
elsif file_exists(t1) then
icon = create(GdkPixbuf,t1,BTN_ICON_SIZE,0,1)
else
icon = create(GtkImage,tmp[1],BTN_ICON_SIZE,0,1)
end if
set(btn,"image",icon)
set(btn,"always show image",BTN_SHOW_IMG)
return btn
end if
btn = gtk_func("gtk_radio_button_new",{P},{group})
register(btn,GtkRadioButton)
return btn
end function
widget[GtkColorButton] = {"gtk_color_button",
{GtkColorChooser,GtkButton,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GtkActionable,GObject},
{"new",{P},-routine_id("newColorButton")},
{"set_title",{P,S}},
{"get_title",{P},S},
{"show_editor",{P,B}}, -- 3.20
"GtkColorButton"}
function newColorButton(object c=0)
if string(c) then c = to_rgba(c) end if
if c=0 then return gtk_func("gtk_color_button_new")
else return gtk_func("gtk_color_button_new_with_rgba",{P},{c})
end if
end function
widget[GtkFontButton] = {"gtk_font_button",
{GtkFontChooser,GtkButton,GtkBin,GtkContainer,GtkWidget,GtkActionable,GtkBuildable,GObject},
{"new",{P,P,P},-routine_id("newFontButton")},
{"set_font_name",{P,S}},
{"get_font_name",{P},S},
{"set_show_style",{P,B}},
{"get_show_style",{P},B},
{"set_show_size",{P,B}},
{"get_show_size",{P},B},
{"set_use_font",{P,B}},
{"get_use_font",{P},B},
{"set_use_size",{P,B}},
{"get_use_size",{P},B},
{"set_title",{P,S}},
{"get_title",{P},S},
"GtkFontButton"}
function newFontButton(object f=0, object fn=0, object data=0)
if string(f) then f = allocate_string(f,1) end if
atom fnt
if f = 0 then
fnt = gtk_func("gtk_font_button_new")
else fnt = gtk_func("gtk_font_button_new_with_font",{P},{f})
end if
if string(fn) or fn > 0 then
connect(fnt,"font-set",fn,data)
end if
return fnt
end function
widget[GtkLinkButton] = {"gtk_link_button",
{GtkButton,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GtkActionable,GObject},
{"new",{S,S},-routine_id("newLinkButton")},
{"set_uri",{P,S}},
{"get_uri",{P},S},
{"set_visited",{P,B}},
{"get_visited",{P},B},
"GtkLinkButton"}
function newLinkButton(object link, object lbl=0)
if lbl = 0 then return gtk_func("gtk_link_button_new",{S},{link})
else return gtk_func("gtk_link_button_new_with_label",{S,S},{link,lbl})
end if
end function
widget[GtkLockButton] = {"gtk_lock_button", -- unable to make this work!
{GtkButton,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GtkActionable,GObject},
{"new",{P},P},
{"set_permission",{P,P}},
{"get_permission",{P},P,0,GPermission},
"GtkLockButton"}
widget[GPermission] = {"g_permission",
{GObject},
{"get_allowed",{P},B},
{"get_can_acquire",{P},B},
{"get_can_release",{P},B},
{"acquire",{P,P,P},B},
{"acquire_async",{P,P,P,P}},
{"acquire_finish",{P,P,P},B},
{"release",{P,P,P},B},
{"release_async",{P,P,P,P}},
{"finish",{P,P,P},B},
{"impl_update",{P,B,B,B}},
"GPermission"}
widget[GSimplePermission] = {"g_simple_permission",
{GPermission},
{"new",{B},P},
"GSimplePermission"}
widget[GtkScaleButton] = {"gtk_scale_button",
{GtkButton,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GtkOrientable,GtkActionable,GObject},
{"new",{I,D,D,D,P},P},
{"set_adjustment",{P,P}},
{"get_adjustment",{P},P,0,GtkAdjustment},
{"set_value",{P,D}},
{"get_value",{P},D},
{"get_popup",{P},P,0,GtkWidget},
{"get_plus_button",{P},P,0,GtkButton},
{"get_minus_button",{P},P,0,GtkButton},
{"set_icons",{P,A}},
"GtkScaleButton"}
widget[GtkMenu] = {"gtk_menu",
{GtkMenuShell,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{P},-routine_id("newMenu")},
{"attach",{P,P,I,I,I,I}},
{"attach_to_widget",{P,P,P}},
{"get_attach_widget",{P},P,0,GtkWidget},
{"get_for_attach_widget",{P},P,0,GList},
{"detach",{P}},
{"popup",{P,P,P,P,P,I,I}},
{"popdown",{P}},
{"reposition",{P}},
{"set_active",{P,I}},
{"get_active",{P},P,0,GtkMenuItem},
{"popup_for_device",{P,P,P,P,P,P,P,I,I}},
{"set_accel_group",{P,P}},
{"get_accel_group",{P},P,0,GtkAccelGroup},
{"set_accel_path",{P,S}},
{"get_accel_path",{P},S},
{"set_title",{P,S}}, -- deprecated 3.10
{"get_title",{P},S}, -- deprecated 3.10
{"set_monitor",{P,I}},
{"get_monitor",{P},I},
{"set_tearoff_state",{P,B}}, -- deprecated 3.10
{"get_tearoff_state",{P},B}, -- deprecated 3.10
{"set_reserve_toggle_size",{P,B}},
{"get_reserve_toggle_size",{P},B},
{"set_screen",{P,P}},
{"popup_at_pointer",{P,P}}, -- 3.22
{"popup_at_rect",{P,P,P,I,I,P}}, -- 3.22
{"popup_at_widget",{P,P,I,I,P}}, -- 3.22
"GtkMenu"}
function newMenu(object x=0)
if class_id(x) = GMenuModel then
return gtk_func("gtk_menu_new_from_model",{P},{x})
else
return gtk_func("gtk_menu_new")
end if
end function
widget[GtkMenuBar] = {"gtk_menu_bar",
{GtkMenuShell,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{P},-routine_id("newMenuBar")},
{"set_pack_direction",{P,I}},
{"get_pack_direction",{P},I},
{"set_child_pack_direction",{P,I}},
{"get_child_pack_direction",{P},I},
"GtkMenuBar"}
function newMenuBar(atom x=0)
if class_id(x) = GMenuModel then
return gtk_func("gtk_menu_bar_new_from_model",{P},{x})
else
return gtk_func("gtk_menu_bar_new")
end if
end function
widget[GMenu] = {"g_menu",
{GMenuModel,GObject},
{"new",{},P},
{"freeze",{P}},
{"insert",{P,I,S,S}},
{"prepend",{P,S,S}},
{"append",{P,S,S}},
{"insert_item",{P,I,P}},
{"append_item",{P,P}},
{"prepend_item",{P,P}},
{"insert_section",{P,I,S,P}},
{"prepend_section",{P,S,P}},
{"append_section",{P,S,P}},
{"append_submenu",{P,S,P}},
{"insert_submenu",{P,I,S,P}},
{"prepend_submenu",{P,S,P}},
{"remove",{P,I}},
"GMenu"}
widget[GMenuModel] = {"g_menu_model",
{GObject},
{"is_mutable",{P},B},
{"get_n_items",{P},I},
{"get_item_attribute",{P,I,S,S,P},B},
{"get_item_link",{P,I,S},P,0,GMenuModel},
{"items_changed",{P,I,I,I}},
"GMenuModel"}
widget[GMenuItem] = {"g_menu_item",
{GObject},
{"new",{S,S},P},
{"new_section",{S,P},P,0,GMenuItem},
{"new_submenu",{S,P},P,0,GMenuItem},
{"set_label",{P,S}},
{"set_action_and_target_value",{P,S,P}},
{"set_detailed_action",{P,S}},
{"set_section",{P,P}},
{"set_submenu",{P,P}},
{"set_attribute_value",{P,P,P}},
{"set_link",{P,S,P}},
"GMenuItem"}
widget[GtkMenuButton] = {"gtk_menu_button", --3.6
{GtkToggleButton,GtkButton,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GtkActionable,GObject},
{"new",{},P},
{"set_popup",{P,P}},
{"get_popup",{P},P,0,GtkMenu},
{"set_menu_model",{P,P}},
{"get_menu_model",{P},P,0,GMenuModel},
{"set_direction",{P,I}},
{"get_direction",{P},I},
{"set_align_widget",{P,P}},
{"get_align_widget",{P},P,0,GtkWidget},
{"set_popover",{P,P}}, -- 3.12
{"get_popover",{P},P,0,GtkPopover}, -- 3.12
{"set_use_popover",{P,B}}, -- 3.12
{"get_use_popover",{P},B}, -- 3.12
"GtkMenuButton"}
widget[GtkMenuItem] = {"gtk_menu_item",
{GtkBin,GtkContainer,GtkWidget,GtkBuildable,GtkActionable,GObject},
{"new",{P,P,P,P},-routine_id("newMenuItem")},
{"set_label",{P,S},-routine_id("mi_set_label")},
{"get_label",{P},-routine_id("mi_get_label")},
{"set_image",{P,P},-routine_id("mi_set_image")},
{"get_image",{P},-routine_id("mi_get_image")},
{"set_use_underline",{P,B}},
{"get_use_underline",{P},B},
{"set_submenu",{P,P}},
{"get_submenu",{P},P,0,GtkWidget},
{"select",{P}},
{"deselect",{P}},
{"activate",{P}},
{"toggle_size_allocate",{P,I}},
{"set_reserve_indicator",{P,B}},
{"get_reserve_indicator",{P},B},
{"add_accelerator",{P,P,P},-routine_id("mi_add_accelerator")},
"GtkMenuItem"}
-- all this just to allow images and accels on menu items!
constant activate = allocate_string("activate")
function newMenuItem(object stk=0, object fn=0, object data=0, object accels=0)
object item, img = 0
if match("#",stk) then
stk = split(stk,'#')
img = stk[1]
stk = stk[2]
goto "next"
end if
if not match("#",stk) then
if match("gtk-",stk) then
img = stk
stk = "_" & proper(stk[5..$])
end if
end if
label "next"
item = gtk_func("gtk_menu_item_new_with_mnemonic",{P},{allocate_string(stk,1)})
register(item,GtkMenuItem)
label "accels "
if atom(img) and img = 0 then
item = mi_add_accelerator(item,accels)
else
item = mi_add_accelerator(item,accels,img)
end if
return item
end function
function mi_add_accelerator(atom item, object accels, object img = 0)
atom x = allocate(8,1)
integer key, mods
object child = get(item,"child")
if atom(img) and img = 0 then -- do nothing
else
img = get_icon_image(img,3)
end if
if sequence(accels) then
gtk_proc("gtk_accelerator_parse", {P,P,P},
{allocate_string(accels[2],1),x,x+4})
key = peek4u(x) mods = peek4u(x+4)
gtk_proc("gtk_widget_add_accelerator",{P,P,P,I,I,I},
{item,activate,accels[1],key,mods,GTK_ACCEL_VISIBLE})
if class_id(child) = -1 then
gtk_proc("gtk_accel_label_set_accel_widget",{P,P},{child,item})
gtk_proc("gtk_accel_label_set_accel",{P,I,I},{child,key,mods})
end if
end if
gtk_proc("g_object_ref",{P},{child})
gtk_proc("gtk_container_remove",{P,P},{item,child})
atom box = create(GtkButtonBox)
set(box,"margin left",0)
set(box,"layout",GTK_BUTTONBOX_START)
if atom(img) and img > 0 then
add(box,img)
register(img,GtkImage)
set(box,"halign",0)
set(img,"margin left",0)
set(img,"margin right",0)
set(box,"child non_homogeneous",img,TRUE)
end if
register(child,GtkAccelLabel)
pack_start(box,child,1,1) -- put the label back
set(box,"child non_homogeneous",child,TRUE)
set(child,"halign",0)
set(child,"margin left",0)
if sequence(accels) then
object txt = gtk_str_func("gtk_accelerator_get_label",{I,I},{key,mods})
if string(txt) then
atom acc = create(GtkLabel)
set(acc,"padding",0,0)
set(acc,"markup",txt)
if sequence(ACCEL_FONT) then
set(acc,"font",ACCEL_FONT)
end if
add(box,acc)
set(box,"child secondary",acc,TRUE)
set(box,"child non_homogeneous",acc,TRUE)
end if
end if
add(item,box)
return item
end function
function mi_set_label(atom item, object lbl)
if string(lbl) then lbl = allocate_string(lbl,1) end if
atom b = get(item,"child")
object list = get(b,"children")
if atom(list) then
list &= 0
end if
for i = 1 to length(list) do
if class_id(list[i]) = GtkAccelLabel then
gtk_proc("gtk_label_set_text",{P,P},{list[i],lbl})
return 1
end if
end for
return 1
end function
export function mi_get_label(atom item)
atom b = get(item,"child")
object list = get(b,"children")
for i = 1 to length(list) do
if class_id(list[i]) = GtkAccelLabel then
return gtk_str_func("gtk_label_get_text",{P},{list[i]})
end if
end for
return 0
end function
function mi_set_image(atom item, object img)
if string(img) then img = get_icon_image(img,GTK_ICON_SIZE_MENU) end if
img = get(img,"pixbuf")
atom b = get(item,"child")
object l = get(b,"children")
for i = 1 to length(l) do
if class_id(l[i]) = GtkImage then
gtk_proc("gtk_image_set_from_pixbuf",{P,P},{l[i],img})
return 1
end if
end for
return 1
end function
function gmi_get_image(atom item)
atom b = get(item,"child")
object l = get(b,"children")
for i = 1 to length(l) do
if class_id(l[i]) = GtkImage then
return l[i]
end if
end for
return 1
end function
function mi_set_use_underline(atom item, boolean use)
atom b = get(item,"child")
object l = get(b,"children")
for i = 1 to length(l) do
if class_id(l[i]) = GtkAccelLabel then
gtk_proc("gtk_label_set_use_underline",{P,B},{l[i],use})
return 1
end if
end for
return 1
end function
function mi_get_use_underline(atom item)
atom b = get(item,"child")
object l = get(b,"children")
l = to_sequence(l,1)
for i = 1 to length(l) do
if class_id(l[i]) = GtkAccelLabel then
return gtk_func("gtk_label_get_use_underline",{P},{l[i]})
end if
end for
return 1
end function
widget[GtkImageMenuItem] = {"gtk_image_menu_item",
{GtkMenuItem,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{P,P,P,P},-routine_id("newMenuItem")},
"GtkImageMenuItem"}
widget[GtkRadioMenuItem] = {"gtk_radio_menu_item",
{GtkCheckMenuItem,GtkMenuItem,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GtkActionable,GObject},
{"new",{P,P,P,P,P},-routine_id("newRadioMenuItem")},
{"set_group",{P,P}},
{"get_group",{P},P},
{"join_group",{P,P}}, -- 3.18
"GtkRadioMenuItem"}
function newRadioMenuItem(atom group, object stk, object fn, object data, object accels=0)
object item, img = 0
if match("#",stk) then
stk = split(stk,'#')
img = stk[1]
stk = stk[2]
goto "next"
end if
if not match("#",stk) then
if match("gtk-",stk) then
img = stk
end if
end if
label "next"
if group = 0 then
item = gtk_func("gtk_radio_menu_item_new_with_mnemonic",{P,P},
{group,allocate_string(stk,1)})
else
item = gtk_func("gtk_radio_menu_item_new_with_mnemonic_from_widget",
{P,P},{group,allocate_string(stk,1)})
end if
register(item,GtkMenuItem)
if atom(img) and img = 0 then
item = mi_add_accelerator(item,accels)
else
item = mi_add_accelerator(item,accels,img)
end if
return item
end function
widget[GtkCheckMenuItem] = {"gtk_check_menu_item",
{GtkMenuItem,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GtkActionable,GObject},
{"new",{P,P,P,P},-routine_id("newCheckMenuItem")},
{"set_active",{P,B}},
{"get_active",{P},B},
{"toggled",{P}},
{"set_inconsistent",{P,B}},
{"get_inconsistent",{P},B},
{"set_draw_as_radio",{P,B}},
{"get_draw_as_radio",{P},B},
"GtkCheckMenuItem"}
function newCheckMenuItem(object stk,object fn, object data, object accels=0)
object item, img = 0
if match("#",stk) then
stk = split(stk,'#')
img = stk[1]
stk = stk[2]
goto "next"
end if
if not match("#",stk) then
if match("gtk-",stk) then
img = stk
end if
end if
label "next"
item = gtk_func("gtk_check_menu_item_new_with_mnemonic",{P},{allocate_string(stk,1)})
register(item,GtkCheckMenuItem)
if atom(img) and img = 0 then
item = mi_add_accelerator(item,accels)
else
item = mi_add_accelerator(item,accels,img)
end if
return item
end function
widget[GtkNumerableIcon] = {"gtk_numerable_icon", -- deprecated 3.14
{GEmblemedIcon,GObject},
{"new",{P},P,0,GIcon},
{"new_with_style_context",{P,P},P,0,GIcon},
{"get_background_gicon",{P},P,0,GIcon},
{"set_background_gicon",{P,P}},
{"get_background_icon_name",{P},S},
{"set_background_icon_name",{P,S}},
{"get_count",{P},I},
{"set_count",{P,I}},
{"get_label",{P},S},
{"set_label",{P,S}},
{"get_style_context",{P},P,0,GtkStyleContext},
{"set_style_context",{P,P}},
"GtkNumerableIcon"}
widget[GtkEventBox] = {"gtk_event_box",
{GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{},P},
{"set_above_child",{P,B}},
{"get_above_child",{P},B},
{"set_visible_window",{P,B}},
{"get_visible_window",{P},B},
"GtkEventBox"}
widget[GtkExpander] = {"gtk_expander",
{GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{P},-routine_id("newExpander")},
{"set_spacing",{P,I}},
{"get_spacing",{P},I},
{"set_expanded",{P,B}},
{"get_expanded",{P},B},
{"set_label",{P,S}},
{"get_label",{P},S},
{"set_label_widget",{P,P}},
{"get_label_widget",{P},P},
{"set_label_fill",{P,B}},
{"get_label_fill",{P},B},
{"set_use_underline",{P,B}},
{"get_use_underline",{P},B},
{"set_use_markup",{P,B}},
{"get_use_markup",{P},B},
{"set_resize_toplevel",{P,B}},
{"get_resize_toplevel",{P},B},
"GtkExpander"}
function newExpander(object caption="")
if string(caption) and match("_",caption) then
return gtk_func("gtk_expander_new_with_mnemonic",{P},{caption})
else
return gtk_func("gtk_expander_new",{P},{caption})
end if
end function
widget[GtkToolItem] = {"gtk_tool_item",
{GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{},P},
{"set_homogeneous",{P,B}},
{"get_homogeneous",{P},B},
{"set_expand",{P,B}},
{"get_expand",{P},B},
{"set_tooltip_text",{P,S}},
{"set_tooltip_markup",{P,S}},
{"set_use_drag_window",{P,B}},
{"get_use_drag_window",{P},B},
{"set_visible_horizontal",{P,B}},
{"get_visible_horizontal",{P},B},
{"set_visible_vertical",{P,B}},
{"get_visible_vertical",{P},B},
{"set_is_important",{P,B}},
{"get_is_important",{P},B},
{"get_ellipsize_mode",{P},I},
{"get_icon_size",{P},I},
{"get_orientation",{P},I},
{"get_toolbar_style",{P},I},
{"get_relief_style",{P},I},
{"get_text_alignment",{P},F},
{"get_text_orientation",{P},I},
{"retrieve_proxy_menu_item",{P},P,0,GtkMenuItem},
{"set_proxy_menu_item",{P,S,P}},
{"get_proxy_menu_item",{P,S},P,0,GtkMenuItem},
{"rebuild_menu",{P}},
{"toolbar_reconfigured",{P}},
{"get_text_size_group",{P},P,0,GtkSizeGroup},
"GtkToolItem"}
widget[GtkToolButton] = {"gtk_tool_button",
{GtkToolItem,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GtkActionable,GObject},
{"new",{P,P},-routine_id("newToolButton")},
{"set_label",{P,S}},
{"get_label",{P},S},
{"set_use_underline",{P,B}},
{"get_use_underline",{P},B},
{"set_stock_id",{P,S}}, -- deprecated 3.10
{"get_stock_id",{P},S}, -- deprecated 3.10
{"set_icon_name",{P,S}},
{"get_icon_name",{P},S},
{"set_icon_widget",{P,P}},
{"get_icon_widget",{P},P,0,GtkWidget},
{"set_label_widget",{P,P}},
{"get_label_widget",{P},P,0,GtkWidget},
"GtkToolButton"}
function newToolButton(object icn=0, object lbl=0)
--------------------------------------------------
atom btn = 0
if string(icn) then
if match("gtk-",icn) = 1 then
btn = gtk_func("gtk_tool_button_new_from_stock",{P},{allocate_string(icn,1)})
set(btn,"always show icon",TRUE)
return btn
else
icn = create(GtkImage,icn)
end if
end if
if string(lbl) then
lbl = allocate_string(lbl,1)
end if
btn = gtk_func("gtk_tool_button_new",{P,P},{icn,lbl})
return btn
end function
widget[GtkMenuToolButton] = {"gtk_menu_tool_button",
{GtkToolButton,GtkToolItem,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GtkActionable,GObject},
{"new",{P,P},-routine_id("newMenuToolButton")},
{"set_menu",{P,P}},
{"get_menu",{P},P,0,GtkMenu},
{"set_arrow_tooltip_text",{P,S}},
{"set_arrow_tooltip_markup",{P,S}},
"GtkMenuToolButton"}
function newMenuToolButton(object icn=0, object lbl=0)
if string(icn) then
icn = create(GtkImage,icn,1)
end if
if string(lbl) then
lbl = allocate_string(lbl,1)
end if
atom btn = gtk_func("gtk_menu_tool_button_new",{P,P},{icn,lbl})
return btn
end function
widget[GtkToggleToolButton] = {"gtk_toggle_tool_button",
{GtkToolButton,GtkToolItem,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GtkActionable,GObject},
{"new",{S},-routine_id("newToggleToolButton")},
{"set_active",{P,B}},
{"get_active",{P},B},
"GtkToggleToolButton"}
function newToggleToolButton(object x)
atom btn
if string(x) then
btn = gtk_func("gtk_toggle_tool_button_new_from_stock",{S},{x})
elsif atom(x) then
btn = gtk_func("gtk_toggle_tool_button_new")
if class_id(btn) = GdkPixbuf then
set(btn,"image",create(GtkImage,btn))
end if
end if
return btn
end function
widget[GtkRadioToolButton] = {"gtk_radio_tool_button",
{GtkToggleToolButton,GtkToolButton,GtkToolItem,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GtkActionable,GObject},
{"new",{P},-routine_id("newRadioToolButton")},
{"set_group",{P,P}},
{"get_group",{P},P},
"GtkRadioToolButton"}
function newRadioToolButton(atom id)
if class_id(id) = GtkRadioToolButton then
return gtk_func("gtk_radio_tool_button_new_from_widget",{P},{id})
else
return gtk_func("gtk_radio_tool_button_new",{P},{id})
end if
end function
widget[GtkSeparatorToolItem] = {"gtk_separator_tool_item",
{GtkToolItem,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{},P},
{"set_draw",{P,B}},
{"get_draw",{P},B},
"GtkSeparatorToolItem"}
widget[GtkOverlay] = {"gtk_overlay",
{GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{},P},
{"add_overlay",{P,P}},
{"get_overlay_pass_through",{P,P},B}, -- 3.18
{"set_overlay_pass_through",{P,P,B}}, -- 3.18
"GtkOverlay"}
widget[GtkScrollable] = {"gtk_scrollable",
{GObject},
{"set_hadjustment",{P,P}},
{"get_hadjustment",{P},P,0,GtkAdjustment},
{"set_vadjustment",{P,P}},
{"get_vadjustment",{P},P,0,GtkAdjustment},
{"set_hscroll_policy",{P,I}},
{"get_hscroll_policy",{P},I},
{"set_vscroll_policy",{P,I}},
{"get_vscroll_policy",{P},I},
{"get_border",{P,P},B}, -- 3.16
"GtkScrollable"}
widget[GtkScrolledWindow] = {"gtk_scrolled_window",
{GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{P,P},P},
{"set_hadjustment",{P,P}},
{"get_hadjustment",{P},P,0,GtkAdjustment},
{"set_vadjustment",{P,P}},
{"get_vadjustment",{P},P,0,GtkAdjustment},
{"get_hscrollbar",{P},P,0,GtkWidget},
{"get_vscrollbar",{P},P,0,GtkWidget},
{"set_policy",{P,I,I}},
{"get_policy",{P,I,I}},
{"set_placement",{P,I}},
{"unset_placement",{P}},
{"set_shadow_type",{P,I}},
{"get_shadow_type",{P},I},
{"set_min_content_width",{P,I}},
{"get_min_content_width",{P},I},
{"set_min_content_height",{P,I}},
{"get_min_content_height",{P},I},
{"set_kinetic_scrolling",{P,B}},
{"get_kinetic_scrolling",{P},B},
{"set_capture_button_press",{P,B}},
{"get_capture_button_press",{P},B},
{"set_headers",{P,P}},
{"add_with_viewport",{P,P}}, -- deprecated 3.8
{"get_overlay_scrolling",{P},B}, -- 3.16
{"set_overlay_scrolling",{P,B}}, -- 3.16
"GtkScrolledWindow"}
widget[GtkSidebar] = {"gtk_sidebar", -- 3.16
{GtkBin,GtkContainer,GtkWidget,GObject},
{"new",{},P},
{"set_stack",{P,P}},
{"get_stack",{P},P,0,GtkStack},
"GtkSidebar"}
widget[GtkTextBuffer] = {"gtk_text_buffer",
{GObject},
{"new",{P},P},
{"get_line_count",{P},I},
{"get_char_count",{P},I},
{"get_tag_table",{P},P,0,GtkTextTagTable},
{"insert",{P,P,S,I}},
{"insert_at_cursor",{P,S,I}},
{"insert_interactive",{P,P,S,I,B},B},
{"insert_interactive_at_cursor",{P,S,I,B},B},
{"insert_range",{P,P,P,P}},
{"insert_range_interactive",{P,P,P,P,B},B},
{"insert_with_tags",{P,P,S,I,P,P}},
{"insert_with_tags_by_name",{P,P,S,I,S}},
{"insert_markup",{P,P,S,I}}, -- 3.16
{"delete",{P,P,P}},
{"delete_interactive",{P,P,P,B},B},
{"backspace",{P,P,B,B},B},
{"set_text",{P,P},-routine_id("setBufferText")},
{"get_text",{P},-routine_id("getBufferText")},
{"get_slice",{P,P,P,B},S},
{"insert_pixbuf",{P,P,P}},
{"insert_child_anchor",{P,P,P}},
{"create_child_anchor",{P,P},P,0,GtkTextChildAnchor},
{"create_mark",{P,S,P,B},P,0,GtkTextMark},
{"move_mark",{P,P,P}},
{"move_mark_by_name",{P,S,P}},
{"add_mark",{P,P,P}},
{"delete_mark",{P,P}},
{"delete_mark_by_name",{P,S}},
{"get_mark",{P,S},P,0,GtkTextMark},
{"get_insert",{P},P,0,GtkTextMark},
{"get_selection_bound",{P},P,0,GtkTextMark},
{"get_selection_bounds",{P},-routine_id("getSelectionBounds")},
{"get_has_selection",{P},B},
{"place_cursor",{P,P}},
{"select_range",{P,P,P}},
{"apply_tag",{P,P,P,P}},
{"remove_tag",{P,P,P,P}},
{"apply_tag_by_name",{P,S,P,P}},
{"remove_tag_by_name",{P,S,P,P}},
{"remove_all_tags",{P,P,P}},
{"create_tag",{P,S,S,S},P,0,GtkTextTag},
{"get_iter_at_line_offset",{P,P,I,I}},
{"get_iter_at_offset",{P,P,I}},
{"get_iter_at_line",{P,P,I}},
{"get_iter_at_line_index",{P,P,I,I}},
{"get_iter_at_mark",{P,P,P}},
{"get_iter_at_child_anchor",{P,P,P}},
{"get_start_iter",{P,P}},
{"get_end_iter",{P,P}},
{"get_bounds",{P,P,P}},
{"set_modified",{P,B}},
{"get_modified",{P},B},
{"delete_selection",{P,B,B},B},
{"paste_clipboard",{P,P,P,B}},
{"copy_clipboard",{P,P}},
{"cut_clipboard",{P,P,B}},
{"get_selection_bounds",{P,P,P},B},
{"begin_user_action",{P}},
{"end_user_action",{P}},
{"add_selection_clipboard",{P,P}},
{"remove_selection_clipboard",{P,P}},
{"deserialize",{P,P,I,P,I,I,P},B},
{"deserialize_set_can_create_tags",{P,I,B}},
{"deserialize_get_can_create_tags",{P,I},B},
{"get_copy_target_list",{P},P,0,GtkTargetList},
{"get_deserialize_formats",{P,I},P},
{"get_paste_target_list",{P},P,0,GtkTargetList},
{"get_serialize_formats",{P,I},P},
{"register_deserialize_format",{P,S,P,P,P},P},
{"register_deserialize_tagset",{P,S},P},
{"register_serialize_format",{P,S,P,P,P},P},
{"register_serialize_tagset",{P,S},P},
{"serialize",{P,P,P,P,P,I},I},
{"unregister_deserialize_format",{P,P}},
{"unregister_serialize_format",{P,P}},
{"insert_markup",{P,P,S,I}}, -- 3.16
"GtkTextBuffer"}
export constant
fnBufStart = define_proc("gtk_text_buffer_get_start_iter",{P,P}),
fnBufEnd = define_proc("gtk_text_buffer_get_end_iter",{P,P}),
fnBufGet = define_func("gtk_text_buffer_get_text",{P,P,P,B},S),
fnBufSet = define_proc("gtk_text_buffer_set_text",{P,S,I}),
fnBufIns = define_func("gtk_text_buffer_get_insert",{P},P),
fnBufIter = define_proc("gtk_text_buffer_get_iter_at_mark",{P,P,P}),
fnBufBounds = define_func("gtk_text_buffer_get_selection_bounds",{P,P,P},B)
function getBufferText(object buf)
atom start = allocate(64) c_proc(fnBufStart,{buf,start})
atom fini = allocate(64) c_proc(fnBufEnd,{buf,fini})
object result = c_func(fnBufGet,{buf,start,fini,1})
return peek_string(result)
end function
function getSelectionBounds(object buf)
atom start = allocate(100)
atom fini = allocate(100)
atom iter = allocate(100)
if c_func(fnBufBounds,{buf,start,fini}) then
return {start,fini}
else
start = c_func(fnBufIns,{buf})
c_proc(fnBufIter,{buf,iter,start})
return {iter,iter}
end if
end function
function setBufferText(object buf, object txt)
object len
if atom(txt) then
len = peek_string(txt)
len = length(len)
else
len = length(txt)
txt = allocate_string(txt)
end if
c_proc(fnBufSet,{buf,txt,len})
return 1
end function
widget[GtkClipboard] = {"gtk_clipboard",
{GObject},
{"new",{I},-routine_id("newClipboard")},
{"get_default",{P},P,0,GtkClipboard},-- 3.16
{"get_for_display",{P,I},P,0,GtkClipboard},
{"get_display",{P},P,0,GdkDisplay},
{"set_with_data",{P,P,I,P,P,P},B},
{"set_with_owner",{P,P,I,P,P,P},B},
{"get_owner",{P},P,0,GObject},
{"clear",{P}},
{"set_text",{P,S,I}},
{"set_image",{P,P}},
{"request_contents",{P,I,P,P}},
{"request_text",{P,P,P}},
{"request_image",{P,P,P}},
{"request_targets",{P,P,P}},
{"request_rich_text",{P,P,P,P}},
{"request_uris",{P,P,P}},
{"wait_for_contents",{P,I},P,0,GtkSelectionData},
{"wait_for_text",{P},S},
{"wait_for_image",{P},P,0,GdkPixbuf},
{"wait_for_rich_text",{P,P,I,I},I},
{"wait_for_uris",{P},A},
{"wait_is_text_available",{P},B},
{"wait_is_image_available",{P},B},
{"wait_is_rich_text_available",{P,P},B},
{"wait_is_uris_available",{P},B},
{"wait_for_targets",{P,P,I},B},
{"wait_is_target_available",{P,I},B},
{"set_can_store",{P,P,I}},
{"store",{P}},
{"get_selection",{P},P}, -- 3.22
"GtkClipboard"}
function newClipboard(integer i=0) -- just use default clipboard;
return gtk_func("gtk_clipboard_get",{I},{i})
end function
widget[GtkSelectionData] = {"gtk_selection_data",
{0},
{"set",{P,I,I,S,I}},
{"set_text",{P,S,I},B},
{"get_text",{P},S},
{"set_pixbuf",{P,P},B},
{"get_pixbuf",{P},P,0,GdkPixbuf},
{"set_uris",{P,S},B},
{"get_uris",{P},A},
{"get_targets",{P,P,I},B},
{"targets_include_image",{P,B},B},
{"targets_include_text",{P},B},
{"targets_include_uri",{P},B},
{"targets_include_rich_text",{P,P},B},
{"get_selection",{P},P},
{"get_data",{P},S},
{"get_length",{P},I},
{"get_data_with_length",{P,I},S},
{"get_data_type",{P},I},
{"get_display",{P},P,0,GdkDisplay},
{"get_format",{P},I},
{"get_target",{P},I},
"GtkSelectionData"}
widget[GtkCellArea] = {"gtk_cell_area",
{GtkCellLayout,GtkBuildable,GObject},
{"add",{P,P}},
{"remove",{P,P}},
{"set_property",{P,P,S,P}},
{"get_property",{P,P,S,P}},
{"has_renderer",{P,P},B},
{"foreach",{P,P}},
{"foreach_alloc",{P,P,P,P,P,P,P}},
{"event",{P,P,P,P,P,I},I},
{"render",{P,P,P,P,P,P,I,B}},
{"get_cell_allocation",{P,P,P,P,P,P}},
{"get_cell_at_position",{P,P,P,P,I,I,P},P,0,GtkCellRenderer},
{"create_context",{P},P,0,GtkCellAreaContext},
{"copy_context",{P,P},P,0,GtkCellAreaContext},
{"get_request_mode",{P},I},
{"get_preferred_width",{P,P,P,I,I}},
{"get_preferred_height_for_width",{P,P,P,I,I,I}},
{"get_preferred_height",{P,P,P,I,I}},
{"get_preferred_width_for_height",{P,P,P,I,I,I}},
{"get_current_path",{P},S},
{"apply_attributes",{P,P,P,B,B}},
{"attribute_connect",{P,P,S,I}},
{"attribute_disconnect",{P,P,S}},
{"attribute_get_column",{P,P,S},I}, -- 3.14
{"is_activatable",{P},B},
{"activate",{P,P,P,P,I,B},B},
{"activate_cell",{P,P,P,P,P,I},B},
{"focus",{P,I},B},
{"set_focus_cell",{P,P}},
{"get_focus_cell",{P},P,0,GtkCellRenderer},
{"add_focus_sibling",{P,P,P}},
{"remove_focus_sibling",{P,P,P}},
{"is_focus_sibling",{P,P,P},B},
{"get_focus_siblings",{P,P},X,0,GList},
{"get_focus_from_sibling",{P,P},P,0,GtkCellRenderer},
{"get_edited_cell",{P},P,0,GtkCellRenderer},
{"get_edit_widget",{P},P,0,GtkCellEditable},
{"stop_editing",{P,B}},
{"inner_cell_area",{P,P,P,P}},
{"request_renderer",{P,P,P,P,I,I,I}},
{"class_install_property",{P,I,P}},
{"class_find_cell_property",{P,S},P},
{"class_list_cell_properties",{P,I},P},
"GtkCellArea"}
widget[GtkCellAreaCell] = {"gtk_cell_area_cell",
{GtkCellArea},
{"set_property",{P,P,S,P}},
{"get_property",{P,P,S,P}},
"GtkCellAreaCell"}
widget[GtkCellAreaBox] = {"gtk_cell_area_box",
{GtkCellLayout,GtkCellArea,GtkBuildable,GtkOrientable,GObject},
{"new",{},P},
{"pack_start",{P,P,B,B,B}},
{"pack_end",{P,P,B,B,B}},
{"set_spacing",{P,I}},
{"get_spacing",{P},I},
"GtkCellAreaBox"}
widget[GtkCellAreaContext] = {"gtk_cell_area_context",
{GObject},
{"get_area",{P},P,0,GtkCellArea},
{"allocate",{P,I,I}},
{"reset",{P}},
{"get_preferred_width",{P,I,I}},
{"get_preferred_height",{P,I,I}},
{"get_preferred_height_for_width",{P,I,I,I}},
{"get_preferred_width_for_height",{P,I,I,I}},
{"get_allocation",{P,I,I}},
{"push_preferred_width",{P,I,I}},
{"push_preferred_height",{P,I,I}},
"GtkCellAreaContext"}
widget[GtkCellEditable] = {"gtk_cell_editable",
{GtkWidget},
{"start_editing",{P,P}},
{"editing_done",{P}},
{"remove_widget",{P}},
"GtkCellEditable"}
widget[GtkCellLayout] = {"gtk_cell_layout",
{GObject},
{"pack_start",{P,P,B}},
{"pack_end",{P,P,B}},
{"get_area",{P},P,0,GtkCellArea},
{"get_cells",{P},X,0,GList},
{"reorder",{P,P,I}},
{"clear",{P}},
{"add_attribute",{P,P,S,I}},
{"set_cell_data_func",{P,P,P,P,P}},
{"clear_attributes",{P,P}},
"GtkCellLayout"}
widget[GtkCellRenderer] = {"gtk_cell_renderer",
{GObject},
{"set_fixed_size",{P,I,I}},
{"get_fixed_size",{P,I,I}},
{"set_visible",{P,B}},
{"get_visible",{P},B},
{"set_sensitive",{P,B}},
{"get_sensitive",{P},B},
{"set_alignment",{P,F,F}},
{"get_alignment",{P,F,F}},
{"set_padding",{P,I,I}},
{"get_padding",{P,I,I}},
{"get_state",{P,P,I},I},
{"is_activatable",{P},B},
{"get_aligned_area",{P,P,I,P,P}},
{"render",{P,P,P,P,P,I}},
{"activate",{P,P,P,P,P,P,I},B},
{"start_editing",{P,P,P,P,P,P,I},P,0,GtkCellEditable},
{"stop_editing",{P,B}},
{"get_preferred_height",{P,P,I,I}},
{"get_preferred_width",{P,P,I,I}},
{"get_preferred_height_for_width",{P,P,I,I,I}},
{"get_preferred_width_for_height",{P,P,I,I,I}},
{"get_preferred_size",{P,P,P,P}},
{"get_request_mode",{P},I},
"GtkCellRenderer"}
-- Many properties exist for cell renderers, see GTK docs!
widget[GtkCellRendererAccel] = {"gtk_cell_renderer_accel",
{GtkCellRendererText,GtkCellRenderer,GObject},
{"new",{},P},
"GtkCellRendererAccel"}
widget[GtkCellRendererCombo] = {"gtk_cell_renderer_combo",
{GtkCellRendererText,GtkCellRenderer,GObject},
{"new",{},P},
"GtkCellRendererCombo"}
widget[GtkCellRendererText] = {"gtk_cell_renderer_text",
{GtkCellRenderer,GObject},
{"new",{},P},
{"set_fixed_height_from_font",{P,I}},
"GtkCellRendererText"}
widget[GtkCellRendererPixbuf] = {"gtk_cell_renderer_pixbuf",
{GtkCellRenderer,GObject},
{"new",{},P},
"GtkCellRendererPixbuf"}
widget[GtkCellRendererProgress] = {"gtk_cell_renderer_progress",
{GtkOrientable,GtkCellRenderer,GObject},
{"new",{},P},
"GtkCellRendererProgress"}
widget[GtkCellRendererSpin] = {"gtk_cell_renderer_spin",
{GtkCellRendererText,GtkCellRenderer,GObject},
{"new",{},P},
"GtkCellRendererSpin"}
widget[GtkCellRendererSpinner] = {"gtk_cell_renderer_spinner",
{GtkCellRenderer,GObject},
{"new",{},P},
"GtkCellRendererSpinner"}
widget[GtkCellRendererToggle] = {"gtk_cell_renderer_toggle",
{GtkCellRenderer,GObject},
{"new",{},P},
{"set_radio",{P,B}},
{"get_radio",{P},B},
{"set_active",{P,B}},
{"get_active",{P},B},
{"set_activatable",{P,B}},
{"get_activatable",{P},B},
"GtkCellRendererToggle"}
widget[GtkTreeModelFilter] = {"gtk_tree_model_filter",
{GtkTreeModel,GtkTreeDragSource,GObject},
{"new",{P,P},P},
{"set_visible_func",{P,P,P,P}},
{"set_modify_func",{P,I,P,P,P,P}},
{"set_visible_column",{P,I}},
{"get_model",{P},P,0,GtkTreeModel},
{"convert_child_iter_to_iter",{P,P,P},B},
{"convert_iter_to_child_iter",{P,P,P},B},
{"convert_child_path_to_path",{P,P},P,0,GtkTreePath},
{"convert_path_to_child_path",{P,P},P,0,GtkTreePath},
{"refilter",{P}},
{"clear_cache",{P}},
"GtkTreeModelFilter"}
widget[GtkTreeModelSort] = {"gtk_tree_model_sort",
{GtkTreeSortable,GtkTreeModel,GtkTreeDragSource,GObject},
{"new_with_model",{P},P},
{"get_model",{P},P,0,GtkTreeModel},
{"convert_child_path_to_path",{P,P},P,0,GtkTreePath},
{"convert_child_iter_to_iter",{P,P,P},B},
{"convert_path_to_child_path",{P,P},P,0,GtkTreePath},
{"convert_iter_to_child_iter",{P,P,P}},
{"reset_default_sort_func",{P}},
{"clear_cache",{P}},
"GtkTreeModelSort"}
widget[GtkListStore] = {"gtk_list_store",
{GtkTreeModel,GtkTreeSortable,GtkTreeDragSource,GtkTreeDragDest,GtkBuildable,GObject},
{"new",{P},-routine_id("newListStore")},
{"clear",{P}},
{"set_data",{P,P},-routine_id("ls_set_data")},
{"get_data",{P},-routine_id("ls_get_data")},
{"get_n_rows",{P},-routine_id("ls_get_n_rows")},
{"get_n_cols",{P},-routine_id("ls_get_n_cols")},
{"set_row_data",{P,I,P},-routine_id("ls_set_row_data")},
{"get_row_data",{P,I},-routine_id("ls_get_row_data")},
{"set_col_data",{P,I,I,P},-routine_id("ls_set_col_data")},
{"get_col_data",{P,I,I},-routine_id("ls_get_col_data")},
{"get_col_data_from_iter",{P,I,I},-routine_id("ls_get_col_data_from_iter")},
{"remove_row",{P,I},-routine_id("ls_remove_row")},
{"replace_row",{P,I,P},-routine_id("ls_replace_row")},
{"insert_row",{P,I,P},-routine_id("ls_insert_row")},
{"prepend_row",{P,P},-routine_id("ls_prepend_row")},
{"append_row",{P,P},-routine_id("ls_append_row")},
{"set_swap_rows",{P,I,I},-routine_id("ls_set_swap_rows")},
{"set_move_before",{P,I,I},-routine_id("ls_set_move_before")},
{"set_move_after",{P,I,I},-routine_id("ls_set_move_after")},
"GtkListStore"}
-- almost all calls to GtkListStore are overridden with Euphoria calls,
-- because the GTK versions are just too complex and tedious to set up,
-- making them impractical to use.
constant
TM1 = define_func("gtk_tree_model_get_iter_first",{P,P},I),
TM2 = define_func("gtk_tree_model_iter_next",{P,P},I),
TM3 = define_func("gtk_tree_model_get_iter_from_string",{P,P,P},P),
TM4 = define_proc("gtk_tree_model_get",{P,P,I,P,I}),
TM5 = define_func("gtk_tree_model_get_column_type",{P,I},I),
LS0 = define_proc("gtk_list_store_clear",{P}),
LS1 = define_proc("gtk_list_store_insert",{P,P,I}),
LS2 = define_proc("gtk_list_store_append",{P,P}),
LS3 = define_proc("gtk_list_store_swap",{P,P,P}),
LS4 = define_proc("gtk_list_store_move_before",{P,P,P}),
LS5 = define_proc("gtk_list_store_move_after",{P,P,P}),
LS6 = define_func("gtk_list_store_iter_is_valid",{P,P},B)
function newListStore(object params)
object proto = I & repeat(P,length(params))
params = length(params) & params -- must build func params 'on the fly'
atom fn = define_func("gtk_list_store_new",proto,P)
return c_func(fn,params)
end function
function ls_get_n_rows(object store)
return gtk_func("gtk_tree_model_iter_n_children",{P,P},{store,0})
end function
function ls_get_n_cols(object store)
return gtk_func("gtk_tree_model_get_n_columns",{P},{store})
end function
function ls_set_data(object store, object data)
atom iter = allocate(32,1)
for row = 1 to length(data) do
c_proc(LS1,{store,iter,length(data)}) -- new row
if string(data[row]) then
ls_set_row_data(store,row,{data[row]})
else
ls_set_row_data(store,row,data[row])
end if
end for
return 1
end function
function ls_set_row_data(atom store, integer row, object data)
integer max_col = ls_get_n_cols(store)
for col = 1 to math:min({length(data),max_col}) do
ls_set_col_data(store,row,col,data[col])
end for
return 1
end function
function ls_set_col_data(object store, object row, integer col, object data)
integer max_col = ls_get_n_cols(store)
if col < 1 or col > max_col then
crash("Invalid column #%d",col)
end if
atom s = allocate_string(sprintf("%d",row-1),1)
atom iter = allocate(32,1)
if not c_func(TM3,{store,iter,s}) then
return -1
end if
object prototype = {P,P,I,P,I}
integer col_type = c_func(TM5,{store,col-1})
switch col_type do
case gSTR then prototype = {P,P,I,S,I}
if atom(data) then data = sprintf("%2.2f",data) end if
case gDBL,gFLT then prototype = {P,P,I,D,I}
case gPIX then prototype = {P,P,I,P,I}
case gINT,gBOOL then prototype = {P,P,I,I,I}
case else
display("Error in []->ls_set_col_data: col [] type [] expects [], got []",
{get(store,"name"),col,col_type,vlookup(col_type,storage_types,1,2,"!"),data})
?1/0
end switch
if string(data) then
data = allocate_string(data) -- don't free these strings!
end if
atom fn = define_proc("gtk_list_store_set",prototype)
object params = {store,iter,col-1,data,-1}
c_proc(fn,params)
return 1
end function
function ls_get_data(object store)
object data = {}
for row = 1 to ls_get_n_rows(store) do
data = append(data,ls_get_row_data(store,row))
end for
return data
end function
function ls_get_row_data(object store, integer row)
object data = {}
integer max_row = ls_get_n_rows(store)
if row > max_row then return -1 end if
integer max_col = ls_get_n_cols(store)
for i = 1 to max_col do
data = append(data,ls_get_col_data(store,row,i))
end for
if max_col = 1 then
return data[1] else return data
end if
end function
function ls_get_col_data(atom store, integer row, integer col)
atom x = allocate(32,1)
object result
ifdef LISTSTORE then
display("Get Col Data ~ row [] col []",{row,col})
end ifdef
integer col_type = c_func(TM5,{store,col-1})
ifdef BITS64 then
poke8(x,col_type)
elsedef
poke4(x,col_type)
end ifdef
atom iter = allocate(32,1)
c_func(TM3,{store,iter,allocate_string(sprintf("%d",row-1),1)})
if gtk_func("gtk_list_store_iter_is_valid",{P,P},{store,iter}) = 0 then
display("Error in ls_get_col_data 2 ") abort(0) end if
c_proc(TM4,{store,iter,col-1,x,-1})
if gtk_func("gtk_list_store_iter_is_valid",{P,P},{store,iter}) = 0 then
display("Error in ls_get_col_data 3") abort(0) end if
switch col_type do
case gSTR then
ifdef BITS64 then -- thanks pete eberlein
result = peek8u(x)
elsedef
result = peek4u(x)
end ifdef
if result > 0 then
result = peek_string(result)
end if
case gINT then result = peek4u(x)
case gBOOL then result = peek(x)
case gDBL then result = float64_to_atom(peek({x,8}))
case gFLT then result = float32_to_atom(peek({x,4}))
case gPIX then result = peek4u(x)
case else display("Error in ls_get_col_data 4") abort(0)
end switch
ifdef LISTSTORE then
display("Result []",{result})
end ifdef
return result
end function
function ls_get_col_data_from_iter(atom store, atom iter, integer col)
atom x = allocate(64,1)
object result
ifdef LISTSTORE then
display("Get Col Data from Iter ~ store [] iter [] col []\n",{store,iter,col})
end ifdef
integer col_type = c_func(TM5,{store,col-1})
ifdef BITS64 then
poke8(x,col_type)
elsedef
poke4(x,col_type)
end ifdef
if gtk_func("gtk_list_store_iter_is_valid",{P,P},{store,iter}) = 0 then
display("Error in ls_get_col_datafromiter 1 ") abort(0) end if
c_proc(TM4,{store,iter,col-1,x,-1})
if gtk_func("gtk_list_store_iter_is_valid",{P,P},{store,iter}) = 0 then
display("Error in ls_get_col_datafromiter 2 ") abort(0) end if
switch col_type do
case gSTR then
ifdef BITS64 then -- thanks pete eberlein
result = peek8u(x)
elsedef
result = peek4u(x)
end ifdef
if result > 0 then
result = peek_string(result)
end if
case gINT then result = peek4u(x)
case gBOOL then result = peek(x)
case gDBL then result = float64_to_atom(peek({x,8}))
case gFLT then result = float32_to_atom(peek({x,4}))
case gPIX then result = peek4u(x)
case else display("Error in ls_get_col_datafromiter 3") abort(0)
end switch
ifdef LISTSTORE then
display("Result []",{result})
end ifdef
return result
end function
function ls_insert_row(object store, object data, integer pos)
object tmp = ls_get_data(store)
tmp = insert(tmp,data,pos)
set(store,"clear")
ls_set_data(store,tmp)
return tmp
end function
function ls_append_row(atom store, object data)
object tmp = ls_get_data(store)
tmp = append(tmp,data)
set(store,"clear")
set(store,"data",tmp)
return tmp
end function
function ls_prepend_row(atom store, object data)
object tmp = ls_get_data(store)
tmp = prepend(tmp,data)
set(store,"clear")
set(store,"data",tmp)
return tmp
end function
function ls_remove_row(atom store, integer row)
object tmp = ls_get_data(store)
tmp = remove(tmp,row)
set(store,"clear")
ls_set_data(store,tmp)
return tmp
end function
function ls_replace_row(atom store, object data, integer row)
object tmp = ls_get_data(store)
set(store,"clear")
tmp = replace(tmp,{data},row)
ls_set_data(store,tmp)
return tmp
end function
function ls_set_swap_rows(atom store, integer row_a, integer row_b)
if get(store,"is sorted") then
Warn(0,,"Can't move items in a sorted list!")
return -1
end if
atom iter_a = allocate(32,1), iter_b = allocate(32,1)
c_func(TM3,{store,iter_a,allocate_string(sprintf("%d",row_a-1),1)})
c_func(TM3,{store,iter_b,allocate_string(sprintf("%d",row_b-1),1)})
c_proc(LS3,{store,iter_a,iter_b})
return get(store,"data")
end function
function ls_set_move_before(atom store, integer row_a, integer row_b)
if get(store,"is sorted") then
Error(0,,"Can't move items in a sorted list!")
return -1
end if
atom iter_a = allocate(32,1), iter_b = allocate(32,1)
c_func(TM3,{store,iter_a,allocate_string(sprintf("%d",row_a-1),1)})
c_func(TM3,{store,iter_b,allocate_string(sprintf("%d",row_b-1),1)})
c_proc(LS4,{store,iter_b,iter_a})
return get(store,"data")
end function
function ls_set_move_after(atom store, integer row_a, integer row_b)
if get(store,"is sorted") then
Error(0,,"Can't move items in a sorted list!")
return -1
end if
atom iter_a = allocate(32,1), iter_b = allocate(32,1)
c_func(TM3,{store,iter_a,allocate_string(sprintf("%d",row_a-1),1)})
c_func(TM3,{store,iter_b,allocate_string(sprintf("%d",row_b-1),1)})
c_proc(LS5,{store,iter_b,iter_a})
return get(store,"data")
end function
widget[GtkTreeStore] = {"gtk_tree_store",
{GtkTreeModel,GtkTreeDragSource,GtkTreeDragDest,GtkTreeSortable,GtkBuildable,GObject},
{"new",{P},-routine_id("newTreeStore")},
{"get_n_rows",{P},-routine_id("ts_get_n_rows")},
{"get_n_cols",{P},-routine_id("ts_get_n_cols")},
{"get_data",{P},-routine_id("ts_get_data")},
{"set_data",{P,P},-routine_id("ts_set_data")},
{"set_row_data",{P,P,P},-routine_id("ts_set_row_data")},
{"remove_row",{P,I},-routine_id("ts_remove_row")},
{"insert_row",{P,P,P,I}},
{"insert_before",{P,P,P,P}},
{"insert_after",{P,P,P,P}},
{"prepend",{P,P,P}},
{"append",{P,P,P}},
{"is_ancestor",{P,P,P},B},
{"iter_depth",{P,P},I},
{"clear",{P}},
{"swap",{P,P,P}},
{"move_before",{P,P,P}},
{"move_after",{P,P,P}},
"GtkTreeStore"}
function newTreeStore(object params)
object proto = I & repeat(P,length(params))
params = length(params) & params -- must build func params 'on the fly'
atom fn = define_func("gtk_tree_store_new",proto,P)
return c_func(fn,params)
end function
function ts_get_n_rows(object store)
return gtk_func("gtk_tree_model_iter_n_children",{P,P},{store,0})
end function
function ts_get_n_cols(object store)
return gtk_func("gtk_tree_model_get_n_columns",{P},{store})
end function
function ts_set_data(object store, object data)
atom iter = allocate(32,1)
for row = 1 to length(data) do
gtk_proc("gtk_tree_store_append",{P,P,P},{store,iter,0})
ts_set_row_data(store,data[row],iter)
end for
return 1
end function
constant TSA = define_proc("gtk_tree_store_append",{P,P,P})
-- the following should really be recursive, but that's too complicated
-- for me to figure out! Anyway, four deep should be enough.
function ts_set_row_data(atom store, object data, object parent = 0)
atom iter1 = allocate(32,1)
atom iter2 = allocate(32,1)
atom iter3 = allocate(32,1)
atom iter4 = allocate(32,1)
for i = 1 to length(data) do
if string(data[i]) then
ts_set_row_col_data(store,parent,i,data[i])
else
for j = 1 to length(data[i]) do
if string(data[i][j]) then
c_proc(TSA,{store,iter1,parent})
ts_set_row_col_data(store,iter1,1,data[i][j])
else
for k = 1 to length(data[i][j]) do
if string(data[i][j][k]) then
c_proc(TSA,{store,iter2,iter1})
ts_set_row_col_data(store,iter2,1,data[i][j][k])
else
for l = 1 to length(data[i][j][k]) do
if string(data[i][j][k][l]) then
c_proc(TSA,{store,iter3,iter2})
ts_set_row_col_data(store,iter3,1,data[i][j][k][l])
else
for m = 1 to length(data[i][j][k][l]) do
c_proc(TSA,{store,iter4,iter3})
ts_set_row_col_data(store,iter4,1,data[i][j][k][l][m])
end for
end if
end for
end if
end for
end if
end for
end if
end for
return 1
end function
function ts_set_row_col_data(object store, object iter, integer col, object item)
integer max_col = ts_get_n_cols(store)
if col < 1 or col > max_col then
crash("Invalid column #%d",col)
end if
object prototype = {P,P,I,P,I}
integer col_type
col_type = c_func(TM5,{store,col-1})
switch col_type do
case gDBL,gFLT then prototype = {P,P,I,D,I}
case gSTR, gPIX then prototype = {P,P,I,P,I}
case gBOOL,gINT then prototype = {P,P,I,I,I}
if atom(item) then item = sprintf("%g",item) end if
case else Warn(,,"Unknown column type",
"Expecting gSTR, gBOOL, gINT, gDBL, gFLT, or gPIX")
end switch
if string(item[1]) then item = item[1] end if
if string(item) then item = allocate_string(item,1) end if
atom fn = define_proc("gtk_tree_store_set",prototype)
object params = {store,iter,col-1,item,-1}
c_proc(fn,params)
return iter
end function
function ts_get_data(atom store)
object rowdata = {}
object column = {}
for row = 1 to ts_get_n_rows(store) do
for col = 1 to ts_get_n_cols(store) do
column = append(column,get(store,"col data",col))
end for
rowdata = append(rowdata,column)
column = {}
end for
return rowdata
end function
function ts_remove_row(atom store, integer row)
object tmp = get(store,"data")
tmp = remove(tmp,row)
set(store,"data",tmp)
return tmp
end function
widget[GtkTreeDragSource] = {"gtk_tree_drag_source",
{0},
"GtkTreeDragSource"}
widget[GtkTreeDragDest] = {"gtk_tree_drag_dest",
{0},
"GtkTreeDragDest"}
widget[GtkTreePath] = {"gtk_tree_path",
{GObject},
{"new",{P},-routine_id("newTreePath")},
{"to_string",{P},S},
{"to_integer",{P},-routine_id("tp_to_integer")},
{"new_first",{},P,0,GtkTreePath},
{"append_index",{P,I}},
{"prepend_index",{P,I}},
{"get_depth",{P},I},
{"get_indices",{P},A},
{"get_indices_with_depth",{P,I},A},
{"free",{P}},
{"copy",{P},P,0,GtkTreePath},
{"compare",{P,P},I},
{"next",{P}},
{"prev",{P},B},
{"up",{P},B},
{"down",{P}},
{"is_ancestor",{P,P},B},
{"is_descendant",{P,P},B},
"GtkTreePath"}
function newTreePath(object x=0)
if atom(x) and x > 0 then
x = sprintf("%d",x-1)
end if
if string(x) then
x = allocate_string(x,1)
end if
if x > 0 then
return gtk_func("gtk_tree_path_new_from_string",{P},{x})
else
return gtk_func("gtk_tree_path_new",{},{})
end if
end function
function tp_to_integer(object x)
integer n = to_number(gtk_str_func("gtk_tree_path_to_string",{P},{x}))
return n+1
end function
widget[GtkTreeRowReference] = {"gtk_tree_row_reference",
{GObject},
{"new",{P,P},P,0,GtkTreeRowReference},
{"get_model",{P},P,0,GtkTreeModel},
{"get_path",{P},P,0,GtkTreePath},
{"valid",{P},B},
{"free",{P}},
{"copy",{P},P,0,GtkTreeRowReference},
{"inserted",{P,P}},
{"deleted",{P,P}},
{"reordered",{P,P,P,A}},
"GtkTreeRowReference"}
widget[GtkTreeIter] = {"gtk_tree_iter",
{GObject},
{"new",{},-routine_id("newTreeIter")},
{"copy",{P},P,0,GtkTreeIter},
{"free",{P}},
"GtkTreeIter"}
function newTreeIter()
return allocate(64) -- keep;
end function
widget[GtkTreeModel] = {"gtk_tree_model",
{GObject},
{"get_flags",{P},I},
{"get_n_columns",{P},I},
{"get_column_type",{P,I},I},
{"get_iter",{P,P,P},B},
{"get_iter_first",{P,P},B},
{"get_path",{P,P},P,0,GtkTreePath},
{"get_value",{P,P,I},-routine_id("tm_get_value")},
{"set_value",{P,I,I,P},-routine_id("tm_set_value")},
{"iter_next",{P,P},B},
{"iter_previous",{P,P},B},
{"iter_children",{P,P,P},B},
{"iter_has_child",{P,P},B},
{"iter_n_children",{P,P},I},
{"iter_nth_child",{P,P,P,I},B},
{"iter_parent",{P,P,P},B},
{"get_string_from_iter",{P,P},-routine_id("tm_get_string_from_iter")},
{"ref_node",{P,P}},
{"unref_node",{P,P}},
{"foreach",{P,P,P}},
{"n_rows",{P},-routine_id("tm_get_n_rows")},
{"row_changed",{P,P,P}},
{"row_inserted",{P,P,P}},
{"row_has_child_toggled",{P,P,P}},
{"row_deleted",{P,P}},
{"rows_reordered",{P,P,P,P}},
{"get_iter_n",{P,I},-routine_id("tm_get_iter_n")},
{"get_iter_from_string",{P,P},-routine_id("tm_get_iter_from_string")},
{"get_iter_from_path",{P,P},-routine_id("tm_get_iter_from_path")},
{"get_col_value",{P,P,I},-routine_id("tm_get_col_value")},
{"get_row_values",{P,P},-routine_id("tm_get_row_values")},
{"get_col_data",{P,P,P},-routine_id("tm_get_col_data")},
{"get_row_data",{P,I},-routine_id("tm_get_row_values")},
"GtkTreeModel"}
constant
fntmget = define_proc("gtk_tree_model_get_value",{P,P,I,P}),
fncoltype = define_func("gtk_tree_model_get_column_type",{P,I},I),
gtvfn = define_proc("gtk_tree_model_get",{P,P,I,P,I}),
tmncol = define_func("gtk_tree_model_get_n_columns",{P},I)
function tm_get_n_rows(atom model)
atom fn = define_func("gtk_tree_model_iter_n_children",{P,P},I)
return c_func(fn,{model,0})
end function
function tm_get_string_from_iter(atom model, atom iter)
atom fn = define_func("gtk_tree_model_get_string_from_iter",{P,P},P)
return peek_string(c_func(fn,{model,iter}))
end function
function tm_get_iter_from_string(atom model, object str)
atom iter = allocate(64)
atom fn = define_func("gtk_tree_model_get_iter_from_string",{P,P,P},P)
if string(str) then str = allocate_string(str,1) end if
if c_func(fn,{model,iter,str}) then
return iter
end if
return 0
end function
function tm_get_iter_n(atom model, integer path)
return tm_get_iter_from_string(model,sprintf("%d",path-1))
end function
function tm_get_iter_from_path(atom model, object path)
return tm_get_iter_from_string(model,peek_string(path))
end function
function tm_get_value(atom mdl, atom iter, integer col)
atom x = allocate(64,1)
integer ct = c_func(fncoltype,{mdl,col-1})
object result
ifdef BITS64 then
poke8(x,ct)
elsedef
poke4(x,ct)
end ifdef
c_proc(gtvfn,{mdl,iter,col-1,x,-1})
switch ct do
case gSTR then
ifdef BITS64 then -- thanks pete eberlein
result = peek8u(x)
elsedef
result = peek4u(x)
end ifdef
if result > 0 then
return peek_string(result)
else
return sprintf("%d",result)
end if
case gBOOL,gINT then return peek4u(x)
case gFLT then return float32_to_atom(peek({x,4}))
case gPIX then return peek4u(x)
case else return sprintf("%d",x)
end switch
return sprintf("Oops %d",ct)
end function
function tm_get_row_values(atom mdl, atom iter)
integer ncols = c_func(tmncol,{mdl})
object results = repeat(0,ncols)
for n = 1 to ncols do
results[n] = tm_get_value(mdl,iter,n)
end for
return results
end function
function tm_get_col_value(atom mdl, integer row, integer col)
atom iter = allocate(32,1)
object data = tm_get_row_values(mdl,iter)
return data[col]
end function
function tm_set_col_value(atom mdl, integer row, integer col, object data)
atom iter = tm_get_iter_n(mdl,row)
atom fn = define_proc("gtk_list_store_set",{P,P,I,P,I})
if string(data) then data = allocate_string(data,1) end if
c_proc(fn,{mdl,iter,col-1,data,-1})
return 1
end function
function tm_get_col_data(atom mdl, integer row, integer col)
atom iter = tm_get_iter_n(mdl,row)
object data = tm_get_row_values(mdl,iter)
return data[col]
end function
widget[GtkTreeSortable] = {"gtk_tree_sortable",
{GtkTreeModel,GObject},
{"sort_column_changed",{P}},
{"set_sort_column_id",{P,I,I}},
{"get_sort_column_id",{P},-routine_id("ts_get_sort_col_id")},
{"get_sort_order",{P},-routine_id("ts_get_sort_order")},
{"is_sorted",{P},-routine_id("ts_is_sorted")},
{"set_sort_func",{P,I,P,P,P}},
{"set_default_sort_func",{P,P,P,P}},
{"has_default_sort_func",{P},B},
"GtkTreeSortable"}
function ts_is_sorted(atom mdl)
return gtk_func("gtk_tree_sortable_get_sort_column_id",{P,P,P},{mdl,0,0})
end function
function ts_get_sort_col_id(atom mdl)
integer col = allocate(32,1), order = allocate(32,1)
if gtk_func("gtk_tree_sortable_get_sort_column_id",{P,P,P},{mdl,col,order}) then
return peek4u(col)+1
else
return -1
end if
end function
function ts_get_sort_order(atom mdl)
integer col = allocate(32,1), order = allocate(32,1)
if gtk_func("gtk_tree_sortable_get_sort_column_id",{P,P,P},{mdl,col,order}) then
return peek4u(order)
else
return -1
end if
end function
widget[GtkViewport] = {"gtk_viewport",
{GtkBin,GtkContainer,GtkWidget,GtkBuildable,GtkScrollable,GObject},
{"new",{P,P},P},
{"set_shadow_type",{P,I}},
{"get_shadow_type",{P},I},
{"get_bin_window",{P},P,0,GdkWindow},
{"get_view_window",{P},P,0,GdkWindow},
"GtkViewport"}
widget[GtkAppChooserWidget] = {"gtk_app_chooser_widget",
{GtkBox,GtkContainer,GtkWidget,GtkBuildable,GtkOrientable,GtkAppChooser,GObject},
{"new",{S},P},
{"set_show_default",{P,B}},
{"get_show_default",{P},B},
{"set_show_recommended",{P,B}},
{"get_show_recommended",{P},B},
{"set_show_fallback",{P,B}},
{"get_show_fallback",{P},B},
{"set_show_other",{P,B}},
{"get_show_other",{P},B},
{"set_show_all",{P,B}},
{"get_show_all",{P},B},
{"set_default_text",{P,S}},
{"get_default_text",{P},S},
"GtkAppChooserWidget"}
widget[GtkVolumeButton] = {"gtk_volume_button",
{GtkScaleButton,GtkButton,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GtkOrientable,GtkActionable,GObject},
{"new",{},P},
"GtkVolumeButton"}
widget[GtkColorChooserWidget] = {"gtk_color_chooser_widget",
{GtkColorChooser,GtkBox,GtkContainer,GtkWidget,GtkBuildable,GtkOrientable,GObject},
{"new",{},P},
"GtkColorChooserWidget"}
widget[GtkColorChooser] = {"gtk_color_chooser",
{GObject},
{"set_rgba",{P,P},-routine_id("cc_set_rgba")},
{"get_rgba",{P,I},-routine_id("cc_get_rgba")},
{"set_use_alpha",{P,B},-routine_id("cc_set_alpha")},
{"get_use_alpha",{P},-routine_id("cc_get_alpha")},
{"add_palette",{P,I,I,I,A}},
"GtkColorChooser"}
function cc_set_rgba(atom x, object c)
if string(c) then
c = to_rgba(c)
else
c = to_rgba(text:format("#[X]",c))
end if
gtk_proc("gtk_color_chooser_set_rgba",{P,P},{x,c})
return 1
end function
function cc_get_rgba(atom x, integer fmt)
atom fn = define_proc("gtk_color_chooser_get_rgba",{P,P})
atom rgba = allocate(32,1)
c_proc(fn,{x,rgba})
object c = gtk_func("gdk_rgba_to_string",{P},{rgba})
return fmt_color(c,fmt)
end function
function cc_set_alpha(atom x, integer b)
gtk_proc("gtk_color_chooser_set_use_alpha",{P,B},{x,b})
return 1
end function
function cc_get_alpha(atom x)
atom fn = define_func("gtk_color_chooser_get_use_alpha",{P},B)
return c_func(fn,{x})
end function
widget[GtkColorSelection] = {"gtk_color_selection", -- deprecated
{GtkBox,GtkContainer,GtkWidget,GtkBuildable,GtkOrientable,GObject},
{"new",{},P},
{"set_has_opacity_control",{P,B}},
{"get_has_opacity_control",{P},B},
{"set_has_palette",{P,B}},
{"get_has_palette",{P},B},
{"set_current_rgba",{P,S},-routine_id("cs_set_current_rgba")},
{"get_current_rgba",{P,I},-routine_id("cs_get_current_rgba")},
{"set_current_alpha",{P,I}},
{"get_current_alpha",{P},I},
{"set_previous_rgba",{P,S},-routine_id("cs_set_previous_rgba")},
{"get_previous_rgba",{P,I},-routine_id("cs_get_previous_rgba")},
{"set_previous_alpha",{P,I}},
{"get_previous_alpha",{P},I},
{"is_adjusting",{P},B},
"GtkColorSelection"}
------------------------------------------------------------------------
-- following color functions make using RGB colors much easier,
-- converting automatically between various color notations
------------------------------------------------------------------------
function cs_set_current_rgba(atom x, object c)
c =peek_string(c)
gtk_proc("gtk_color_selection_set_current_rgba",{P,P},{x,to_rgba(c)})
return 1
end function
function cs_set_previous_rgba(atom x, object c)
c = peek_string(c)
gtk_proc("gtk_color_selection_set_previous_rgba",{P,P},{x,to_rgba(c)})
return 1
end function
function cs_get_current_rgba(atom x, integer fmt=0)
atom rgba = allocate(32,1)
atom fn = define_proc("gtk_color_selection_get_current_rgba",{P,P})
c_proc(fn,{x,rgba})
object c = gtk_func("gdk_rgba_to_string",{P},{rgba})
return fmt_color(c,fmt)
end function
function cs_get_previous_rgba(atom x, integer fmt=0)
atom rgba = allocate(32,1)
atom fn = define_proc("gtk_color_selection_get_previous_rgba",{P,P})
c_proc(fn,{x,rgba})
object c = gtk_func("gdk_rgba_to_string",{rgba})
return fmt_color(c,fmt)
end function
widget[GtkNativeDialog] = {"gtk_native_dialog",
{},
{"show",{P}},
{"hide",{P}},
{"destroy",{P}},
{"get_visible",{P},B},
{"set_modal",{P,B}},
{"get_modal",{P},B},
{"set_title",{P,S}},
{"get_title",{P},S},
{"set_transient_for",{P,P}},
{"get_transient_for",{P},P},
{"run",{P}},
"GtkNativeDialog"}
widget[GtkFileChooserNative] = {"gtk_file_chooser_native",
{},
{"new",{S,P,I,S,S},P},
{"get_accept_label",{P},S},
{"set_accept_label",{P,S}},
{"get_cancel_label",{P},S},
{"set_cancel_label",{P,S}},
"GtkFileChooserNative"}
widget[GtkFileChooser] = {"gtk_file_chooser",
{GtkWidget},
{"set_action",{P,I}},
{"get_action",{P},I},
{"set_local_only",{P,B}},
{"get_local_only",{P},B},
{"set_select_multiple",{P,B}},
{"get_select_multiple",{P},B},
{"set_show_hidden",{P,B}},
{"get_show_hidden",{P},B},
{"set_do_overwrite_confirmation",{P,B}},
{"get_do_overwrite_confirmation",{P},B},
{"set_create_folders",{P,B}},
{"get_create_folders",{P},B},
{"get_current_name",{P},S}, --GTK3.10
{"set_current_name",{P,S}},
{"set_filename",{P,S}},
{"get_filename",{P},S},
{"get_filenames",{P},A,0,GSList},
{"select_filename",{P,S}},
{"unselect_filename",{P},S},
{"select_all",{P}},
{"unselect_all",{P}},
{"set_current_folder",{P,S}},
{"get_current_folder",{P},S},
{"set_uri",{P,S}},
{"get_uri",{P},S},
{"select_uri",{P,S}},
{"unselect_uri",{P,S}},
{"get_uris",{P},A,0,GSList},
{"set_current_folder_uri",{P,S}},
{"get_current_folder_uri",{P},S},
{"set_preview_widget",{P,P}},
{"get_preview_widget",{P},P,0,GtkWidget},
{"set_preview_widget_active",{P,B}},
{"get_preview_widget_active",{P},B},
{"set_use_preview_label",{P,B}},
{"get_use_preview_label",{P},B},
{"get_preview_filename",{P},S},
{"get_preview_uri",{P},S},
{"set_extra_widget",{P,P}},
{"get_extra_widget",{P},P,0,GtkWidget},
{"add_filter",{P,P}},
{"remove_filter",{P,P}},
{"list_filters",{P},X,0,GSList},
{"set_filter",{P,P}},
{"get_filter",{P},P,0,GtkFileFilter},
{"add_shortcut_folder",{P,S,P},B},
{"remove_shortcut_folder",{P,S,P},B},
{"list_shortcut_folders",{P},A,0,GSList},
{"add_shortcut_folder_uri",{P,S,P},B},
{"remove_shortcut_folder_uri",{P,S,P},B},
{"list_shortcut_folder_uris",{P},A,0,GSList},
{"get_current_folder_file",{P},P,0,GFile},
{"get_file",{P},P,0,GFile},
{"get_files",{P},X,0,GFile},
{"get_preview_file",{P},P,0,GFile},
{"select_file",{P,P,P},B},
{"set_current_folder_file",{P,P,P},B},
{"set_file",{P,P,P},B},
{"unselect_file",{P,P}},
"GtkFileChooser"}
widget[GtkFileChooserButton] = {"gtk_file_chooser_button",
{GtkFileChooser,GtkBox,GtkContainer,GtkWidget,GtkBuildable,GtkOrientable,GObject},
{"new",{S,I},P},
{"new_with_dialog",{P},P},
{"set_title",{P,S}},
{"get_title",{P},S},
{"set_width_chars",{P,I}},
{"get_width_chars",{P},I},
{"set_focus_on_click",{P,B}},
{"get_focus_on_click",{P},B},
"GtkFileChooserButton"}
widget[GtkFileChooserWidget] = {"gtk_file_chooser_widget",
{GtkFileChooser,GtkBox,GtkContainer,GtkWidget,GtkBuildable,GtkOrientable,GObject},
{"new",{I},P},
"GtkFileChooserWidget"}
widget[GtkFileFilter] = {"gtk_file_filter",
{GtkBuildable,GObject},
{"new",{},P},
{"set_name",{P,S}},
{"get_name",{P},S},
{"add_mime_type",{P,S}},
{"add_pattern",{P,S}},
{"add_pixbuf_formats",{P}},
{"add_custom",{P,I,P,P,P}},
{"get_needed",{P},I},
{"filter",{P,P},B},
"GtkFileFilter"}
widget[GtkFontChooser] = {"gtk_font_chooser",
{GObject},
{"get_font_family",{P},P,0,PangoFontFamily},
{"get_font_face",{P},P,0,PangoFontFace},
{"get_font_size",{P},I},
{"set_font",{P,S}},
{"get_font",{P},S},
{"set_font_desc",{P,P}},
{"get_font_desc",{P},P,0,PangoFontDescription},
{"set_preview_text",{P,S}},
{"get_preview_text",{P},S},
{"set_show_preview_entry",{P,B}},
{"get_show_preview_entry",{P},B},
{"set_filter_func",{P,P,P,P}},
{"get_font_map",{P},P,0,PangoFontMap}, -- 3.18
{"set_font_map",{P,P}}, -- 3.18
"GtkFontChooser"}
widget[GtkFontChooserWidget] = {"gtk_font_chooser_widget",
{GtkFontChooser,GtkBox,GtkContainer,GtkWidget,GtkBuildable,GtkOrientable,GObject},
{"new",{},P},
"GtkFontChooserWidget"}
widget[GtkInfoBar] = {"gtk_info_bar",
{GtkBox,GtkContainer,GtkWidget,GtkBuildable,GtkOrientable,GObject},
{"new",{},P},
{"add_action_widget",{P,P,I}},
{"add_button",{P,S,I},P,0,GtkButton},
{"set_response_sensitive",{P,I,B}},
{"set_default_response",{P,I}},
{"response",{P,I}},
{"set_message_type",{P,I}},
{"get_message_type",{P},I},
{"get_action_area",{P},P,0,GtkWidget},
{"get_content_area",{P},P,0,GtkWidget},
{"set_show_close_button",{P,B}}, -- 3.10
{"get_show_close_button",{P},B}, -- 3.10
"GtkInfoBar"}
widget[GtkRecentChooser] = {"gtk_recent_chooser",
{GObject},
{"set_show_private",{P,B}},
{"get_show_private",{P},B},
{"set_show_not_found",{P,B}},
{"get_show_not_found",{P},B},
{"set_show_icons",{P,B}},
{"get_show_icons",{P},B},
{"set_select_multiple",{P,B}},
{"get_select_multiple",{P},B},
{"set_local_only",{P,B}},
{"get_local_only",{P},B},
{"set_limit",{P,I}},
{"get_limit",{P},I},
{"set_show_tips",{P,B}},
{"get_show_tips",{P},B},
{"set_sort_type",{P,I}},
{"get_sort_type",{P},I},
{"set_sort_func",{P,P,P,P}},
{"set_current_uri",{P,S,P},B},
{"get_current_uri",{P},S},
{"get_current_item",{P},P,0,GtkRecentInfo},
{"select_uri",{P,S,P},B},
{"unselect_uri",{P,S}},
{"select_all",{P}},
{"unselect_all",{P}},
{"get_items",{P},A,0,GSList},
{"get_uris",{P},A},
{"add_filter",{P,P}},
{"remove_filter",{P,P}},
{"list_filters",{P},X,0,GSList},
{"set_filter",{P,P}},
{"get_filter",{P},P,0,GtkRecentFilter},
"GtkRecentChooser"}
widget[GtkRecentChooserWidget] = {"gtk_recent_chooser_widget",
{GtkBox,GtkContainer,GtkWidget,GtkBuildable,GtkOrientable,GtkRecentChooser,GObject},
{"new",{P},-routine_id("newRecentChooserWidget")},
"GtkRecentChooserWidget"}
function newRecentChooserWidget(atom x=0)
if class_id(x) = GtkRecentManager then
return gtk_func("gtk_recent_chooser_widget_new_for_manager",{P},{x})
else
return gtk_func("gtk_recent_chooser_widget_new")
end if
end function
widget[GtkStatusbar] = {"gtk_statusbar",
{GtkBox,GtkContainer,GtkWidget,GtkBuildable,GtkOrientable,GObject},
{"new",{},P},
{"get_context_id",{P,S},I},
{"push",{P,I,S},I},
{"pop",{P,I}},
{"remove",{P,I,I}},
{"remove_all",{P,I}},
{"get_message_area",{P},P},
"GtkStatusBar"}
widget[GtkFixed] = {"gtk_fixed",
{GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{},P},
{"put",{P,P,I,I}},
{"move",{P,P,I,I}},
"GtkFixed"}
widget[GtkGrid] = {"gtk_grid",
{GtkContainer,GtkWidget,GtkBuildable,GtkOrientable,GObject},
{"new",{},P},
{"attach",{P,P,I,I,I,I}},
{"attach_next_to",{P,P,P,I,I,I}},
{"get_child_at",{P,I,I},P,0,GtkWidget},
{"insert_row",{P,I}},
{"remove_row",{P,I}}, --3.10
{"insert_column",{P,I}},
{"remove_column",{P,I}}, --3.10
{"insert_next_to",{P,P,I}},
{"set_row_homogeneous",{P,B}},
{"get_row_homogeneous",{P},B},
{"set_column_homogeneous",{P,B}},
{"get_column_homogeneous",{P},B},
{"set_row_spacing",{P,I}},
{"get_row_spacing",{P},I},
{"set_column_spacing",{P,I}},
{"get_column_spacing",{P},I},
{"set_baseline_row",{P,I}}, --3.10
{"get_baseline_row",{P},I}, --3.10
{"set_row_baseline_position",{P,I,I}}, --3.10
{"get_row_baseline_position",{P,I},I}, --3.10
"GtkGrid"}
widget[GtkPaned] = {"gtk_paned",
{GtkContainer,GtkWidget,GtkBuildable,GtkOrientable,GObject},
{"new",{I},P},
{"add1",{P,P}},
{"add2",{P,P}},
{"pack1",{P,P,B,B}},
{"pack2",{P,P,B,B}},
{"get_child1",{P},P,0,GtkWidget},
{"get_child2",{P},P,0,GtkWidget},
{"set_position",{P,I}},
{"get_position",{P},I},
{"get_handle_window",{P},P,0,GdkWindow},
{"get_wide_handle",{P},B}, -- 3.16
{"set_wide_handle",{P,B}}, -- 3.16
"GtkPaned"}
widget[GtkIconInfo] = {"gtk_icon_info",
{GObject},
{"new",{P,P},-routine_id("newIconInfo")},
{"get_base_size",{P},I},
{"get_base_scale",{P},I}, --3.10
{"get_filename",{P},S},
{"get_display_name",{P},S}, -- deprecated 3.14
{"get_builtin_pixbuf",{P},P,0,GdkPixbuf}, -- deprecated 3.14
{"load_icon",{P},-routine_id("icon_info_load_icon")},
{"load_surface",{P,P,P},P,0,CairoSurface_t},
{"load_icon_async",{P,P,P,P}},
{"load_icon_finish",{P,P,P},P,0,GdkPixbuf},
{"load_symbolic",{P,P,P,P,P,B,P},P,0,GdkPixbuf},
{"load_symbolic_async",{P,P,P,P,P,P,P,P}},
{"load_symbolic_finish",{P,P,P,P},P,0,GdkPixbuf},
{"load_symbolic_for_context",{P,P,P,P},P,0,GdkPixbuf},
{"load_symbolic_for_context_async",{P,P,P,P,P}},
{"load_symbolic_for_context_finish",{P,P,P,P},P,0,GdkPixbuf},
{"set_raw_coordinates",{P,B}}, -- deprecated 3.14
{"get_embedded_rect",{P,P},B}, -- deprecated 3.14
{"get_attach_points",{P,A,P},B}, -- deprecated 3.14
{"is_symbolic",{P},B}, -- 3.12
"GtkIconInfo"}
function newIconInfo(atom theme, atom pix) -- reorder params;
return gtk_func("gtk_icon_info_new_for_pixbuf",{P,P},{theme,pix})
end function
function icon_info_load_icon(atom info) -- allow for err, register object;
atom err = allocate(8,1) err = 0
atom icn = gtk_func("gtk_icon_info_load_icon",{P,P},{info,err})
register(icn,GdkPixbuf)
return icn
end function
widget[GtkIconTheme] = {"gtk_icon_theme",
{GObject},
{"new",{P},-routine_id("newIconTheme")},
{"set_screen",{P,P}},
{"set_search_path",{P,S,I}},
{"get_search_path",{P,P,I}},
{"append_search_path",{P,S}},
{"prepend_search_path",{P,S}},
{"set_custom_theme",{P,S}},
{"has_icon",{P,S},B},
{"lookup_icon",{P,P,I,I},P,0,GtkIconInfo},
{"lookup_icon_for_scale",{P,P,I,I,I},P,0,GtkIconInfo},
{"choose_icon",{P,A,I,I},P,0,GtkIconInfo},
{"choose_icon_for_scale",{P,A,I,I,I},P,0,GtkIconInfo},
{"lookup_by_gicon",{P,P,I,I},P,0,GtkIconInfo},
{"load_icon",{P,S,I,I},-routine_id("icon_theme_load_icon")},
{"load_icon_for_scale",{P,S,I,I,I,P},P,0,GdkPixbuf},
{"load_surface",{P,S,I,I,P,I,P},P,0,CairoSurface_t},
{"list_contexts",{P},-routine_id("icon_theme_list_contexts")},
{"list_icons",{P,S},-routine_id("icon_theme_list_icons")},
{"get_icon_sizes",{P,S},A},
{"rescan_if_needed",{P},B},
{"get_example_icon_name",{P},S},
{"add_builtin_icon",{S,I,P}},
{"add_resource_path",{P,S}}, -- 3.14
"GtkIconTheme"}
function newIconTheme(atom x=0)
if class_id(x) = GdkScreen then
return gtk_func("gtk_icon_theme_get_for_screen",{P},{x})
else
return gtk_func("gtk_icon_theme_get_default")
end if
end function
function icon_theme_load_icon(atom theme, object name, integer size, integer flags)
atom err = allocate(8,1) err = 0
return gtk_func("gtk_icon_theme_load_icon",{P,P,I,I,P},{theme,name,size,flags,err})
end function
function icon_theme_list_contexts(atom theme)
object list = gtk_func("gtk_icon_theme_list_contexts",{P},{theme})
return to_sequence(list)
end function
function icon_theme_list_icons(atom theme, object context)
object list = gtk_func("gtk_icon_theme_list_icons",{P,P},{theme,context})
return to_sequence(list)
end function
widget[GtkIconView] = {"gtk_icon_view",
{GtkCellLayout,GtkScrollable,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{},P},
{"new_with_area",{P},P},
{"new_with_model",{P},P},
{"set_model",{P,P}},
{"get_model",{P},P,0,GtkTreeModel},
{"set_text_column",{P,I}},
{"get_text_column",{P},I},
{"set_markup_column",{P,I}},
{"get_markup_column",{P},I},
{"set_pixbuf_column",{P,I}},
{"get_pixbuf_column",{P},I},
{"get_visible_range",{P,I,I},B},
{"get_path_at_pos",{P,I,I},P,0,GtkTreePath},
{"get_item_at_pos",{P,I,I,I,I},B},
{"convert_widget_to_bin_window_coords",{P,I,I,I,I}},
{"set_cursor",{P,P,P,B}},
{"get_cursor",{P,I,I},B},
{"selected_foreach",{P,P,P}},
{"set_selection_mode",{P,I}},
{"get_selection_mode",{P},I},
{"set_columns",{P,I}},
{"get_columns",{P},I},
{"set_spacing",{P,I}},
{"get_spacing",{P},I},
{"set_row_spacing",{P,I}},
{"get_row_spacing",{P},I},
{"set_column_spacing",{P,I}},
{"get_column_spacing",{P},I},
{"set_margin",{P,I}},
{"get_margin",{P},I},
{"set_item_padding",{P,I}},
{"get_item_padding",{P},I},
{"set_activate_on_single_click",{P,B}}, --3.8
{"get_activate_on_single_click",{P},B}, --3.8
{"get_cell_rect",{P,P,P,P},B}, --3.6
{"select_path",{P,P}},
{"unselect_path",{P,P}},
{"path_is_selected",{P,P},B},
{"get_selected_items",{P},X,0,GList},
{"select_all",{P}},
{"unselect_all",{P}},
{"item_activated",{P,P}},
{"scroll_to_path",{P,P,B,F,F}},
{"get_visible_range",{P,I,I},B},
{"set_tooltip_item",{P,P,P}},
{"set_tooltip_cell",{P,P,P,P}},
{"get_tooltip_context",{P,I,I,B,P,P,P},B},
{"set_tooltip_column",{P,I}},
{"get_tooltip_column",{P},I},
{"get_item_row",{P,P},I},
{"get_item_column",{P,P},I},
{"enable_model_drag_source",{P,I,P,I,I}},
{"enable_model_drag_dest",{P,P,I,I}},
{"unset_model_drag_source",{P}},
{"unset_model_drag_dest",{P}},
{"set_reorderable",{P,B}},
{"get_reorderable",{P},B},
{"set_drag_dest_item",{P,I,I}},
{"get_drag_dest_item",{P,I,I}},
{"get_dest_item_at_pos",{P,I,I,I,I},B},
{"create_drag_icon",{P,P},P,0,CairoSurface_t},
"GtkIconView"}
widget[GtkLayout] = {"gtk_layout",
{GtkContainer,GtkWidget,GtkBuildable,GtkScrollable,GObject},
{"new",{P,P},P},
{"put",{P,P,I,I}},
{"move",{P,P,I,I}},
{"set_size",{P,I,I}},
{"get_size",{P,I,I}},
{"get_bin_window",{P},P,0,GdkWindow},
"GtkLayout"}
widget[GtkSeparatorMenuItem] = {"gtk_separator_menu_item",
{GtkMenuItem,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GtkActionable,GObject},
{"new",{},P},
"GtkSeparatorMenuItem"}
widget[GtkRecentChooserMenu] = {"gtk_recent_chooser_menu",
{GtkMenu,GtkMenuShell,GtkContainer,GtkWidget,GtkBuildable,GtkRecentChooser,GObject},
{"new",{},P},
{"new_for_manager",{P},P},
{"set_show_numbers",{P,B}},
{"get_show_numbers",{P},B},
"GtkRecentChooserMenu"}
widget[GtkRecentFilter] = {"gtk_recent_filter",
{GtkBuildable,GObject},
{"new",{},P},
{"set_name",{P,S}},
{"get_name",{P},S},
{"add_mime_type",{P,S}},
{"add_pattern",{P,S}},
{"add_pixbuf_formats",{P}},
{"add_group",{P,S}},
{"add_age",{P,I}},
{"add_application",{P,S}},
{"add_custom",{P,I,P,P,P}},
{"get_needed",{P},I},
{"filter",{P,P},B},
"GtkRecentFilter"}
widget[GtkRecentInfo] = {"gtk_recent_info",
{GObject},
{"get_uri",{P},S},
{"get_display_name",{P},S},
{"get_description",{P},S},
{"get_mime_type",{P},S},
{"get_added",{P},I},
{"get_modified",{P},I},
{"get_visited",{P},I},
{"get_private_hint",{P},B},
{"get_application_info",{P,S,S,I,I},B},
{"get_applications",{P,I},V},
{"last_application",{P},S},
{"has_application",{P,S},B},
{"create_app_info",{P,S,P},P,0,GAppInfo},
{"get_groups",{P,I},A},
{"has_group",{P,S},B},
{"get_icon",{P,I},P,0,GdkPixbuf},
{"get_gicon",{P},P,0,GIcon},
{"get_short_name",{P},S},
{"get_uri_display",{P},S},
{"get_age",{P},I},
{"is_local",{P},B},
{"exists",{P},B},
{"match",{P,P},B},
"GtkRecentInfo"}
widget[GtkSettings] = {"gtk_settings",
{GtkStyleProvider,GObject},
{"new",{},-routine_id("newSettings")},
{"reset_property",{P,S}}, -- 3.20
"GtkSettings"}
function newSettings(atom x=0)
if class_id(x) = GdkScreen then
return gtk_func("gtk_settings_get_for_screen",{P},{x})
else
return gtk_func("gtk_settings_get_default")
end if
end function
widget[GtkSizeGroup] = {"gtk_size_group",
{GtkBuildable,GObject},
{"new",{I},P},
{"set_mode",{P,I}},
{"get_mode",{P},I},
{"set_ignore_hidden",{P,B}},
{"get_ignore_hidden",{P},B},
{"add_widget",{P,P}},
{"add_widgets",{P,P},-routine_id("sg_add_widgets")},
{"remove_widget",{P,P}},
{"get_widgets",{P},X,0,GSList},
"GtkSizeGroup"}
function sg_add_widgets(atom group, object widgets) -- allow {list} of widgets;
if atom(widgets) then
set(group,"add widget",widgets)
else
for i = 1 to length(widgets) do
set(group,"add widget",widgets[i])
end for
end if
return 1
end function
widget[GtkTargetEntry] = {"gtk_target_entry",
{GObject},
{"new",{S,I,I},P},
{"copy",{P},P,0,GtkTargetEntry},
{"free",{P}},
"GtkTargetEntry"}
widget[GtkTargetList] = {"gtk_target_list",
{GObject},
{"new",{P,I},P},
{"add",{P,P,I,I}},
{"add_table",{P,P,I}},
{"add_text_targets",{P,I}},
{"add_image_targets",{P,I,B}},
{"add_uri_targets",{P,I}},
{"add_rich_text_targets",{P,I,B,P}},
{"remove",{P,P}},
{"find",{P,P,P},B},
"GtkTargetList"}
widget[GtkTextChildAnchor] = {"gtk_text_child_anchor",
{GObject},
{"new",{},P},
{"get_deleted",{P},B},
{"get_widgets",{P},X,0,GList},
"GtkTextChildAnchor"}
widget[GtkTextMark] = {"gtk_text_mark",
{GObject},
{"new",{S,B},P},
{"set_visible",{P,B}},
{"get_visible",{P},B},
{"get_deleted",{P},B},
{"get_name",{P},S},
{"get_buffer",{P},P,0,GtkTextBuffer},
{"get_left_gravity",{P},B},
"GtkTextMark"}
widget[GtkTextTag] = {"gtk_text_tag",
{GObject},
{"new",{S},P},
{"set_priority",{P,I}},
{"get_priority",{P},I},
{"event",{P,P,P,P},B},
{"changed",{P,B}}, -- 3.20
"GtkTextTag"}
widget[GtkTextAttributes] = {"gtk_text_attributes",
{GObject},
{"new",{},P},
{"copy",{P},P,0,GtkTextAttributes},
{"copy_values",{P,P}},
"GtkTextAttributes"}
widget[GtkTextTagTable] = {"gtk_text_tag_table",
{GtkBuildable,GObject},
{"new",{},P},
{"add",{P,P}},
{"remove",{P,P}},
{"lookup",{P,S},P,0,GtkTextTag},
{"foreach",{P,P,P}},
{"get_size",{P},I},
"GtkTextTagTable"}
widget[GtkMenuShell] = {"gtk_menu_shell",
{GtkContainer,GtkWidget,GtkBuildable,GObject},
{"append",{P,P},-routine_id("ms_append")},
{"prepend",{P,P}},
{"insert",{P,P,I}},
{"deactivate",{P}},
{"select_item",{P,P}},
{"select_first",{P,B}},
{"deselect",{P}},
{"activate_item",{P,P,B}},
{"cancel",{P}},
{"set_take_focus",{P,B}},
{"get_take_focus",{P},B},
{"get_selected_item",{P},P,0,GtkWidget},
{"get_parent_shell",{P},P,0,GtkWidget},
{"bind_model",{P,P,S,B}}, --3.6
"GtkMenuShell"}
function ms_append(atom menu, object items) -- allow {list} of items;
if atom(items) then
gtk_proc("gtk_menu_shell_append",{P,P},{menu,items})
else
for i = 1 to length(items) do
ms_append(menu,items[i])
end for
end if
return 1
end function
widget[GtkNotebook] = {"gtk_notebook",
{GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{},P},
{"append_page",{P,P,P},I},
{"append_page_menu",{P,P,P,P},I},
{"prepend_page",{P,P,P},I},
{"prepend_page_menu",{P,P,P,P},I},
{"insert_page",{P,P,P,I},I},
{"insert_page_menu",{P,P,P,P,I},I},
{"remove_page",{P,I}},
{"page_num",{P,I},I},
{"next_page",{P}},
{"prev_page",{P}},
{"reorder_child",{P,P,I}},
{"set_tab_pos",{P,I}},
{"get_tab_pos",{P},I},
{"set_show_tabs",{P,B}},
{"get_show_tabs",{P},B},
{"set_show_border",{P,B}},
{"get_show_border",{P},B},
{"set_scrollable",{P,B}},
{"get_scrollable",{P},B},
{"popup_enable",{P}},
{"popup_disable",{P}},
{"get_current_page",{P},I},
{"set_menu_label",{P,P},0,GtkWidget},
{"get_menu_label",{P,P},P},
{"get_menu_label_text",{P,P},S},
{"get_n_pages",{P},I},
{"get_nth_page",{P,I},P,0,GtkWidget},
{"set_tab_label",{P,P}},
{"get_tab_label",{P,P},P,0,GtkWidget},
{"set_tab_label_text",{P,P,S}},
{"get_tab_label_text",{P,P},S},
{"set_tab_detachable",{P,P,B}},
{"get_tab_detachable",{P,P},B},
{"set_current_page",{P,I}},
{"set_group_name",{P,S}},
{"get_group_name",{P},S},
{"set_action_widget",{P,P,I}},
{"get_action_widget",{P,I},P,0,GtkWidget},
{"detach_tab",{P,P}}, -- 3.16
"GtkNotebook"}
widget[GtkSocket] = {"gtk_socket",
{GtkContainer,GtkWidget,GObject},
{"new",{},P},
{"add_id",{P,P}},
{"get_id",{P},P},
{"get_plug_window",{P},P,0,GdkWindow},
"GtkSocket"}
widget[GtkPlug] = {"gtk_plug",
{GtkWindow,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{I},P},
{"get_id",{P},I},
{"get_embedded",{P},B},
{"get_socket_window",{P},P,0,GdkWindow},
"GtkPlug"}
widget[GtkToolPalette] = {"gtk_tool_palette",
{GtkScrollable,GtkContainer,GtkWidget,GtkBuildable,GtkOrientable,GObject},
{"new",{},P},
{"set_exclusive",{P,P,B}},
{"get_exclusive",{P,P},B},
{"set_expand",{P,P,B}},
{"get_expand",{P,P},B},
{"set_group_position",{P,P,I}},
{"get_group_position",{P,P},I},
{"set_icon_size",{P,I}},
{"get_icon_size",{P},I},
{"unset_icon_size",{P}},
{"set_style",{P,I}},
{"get_style",{P},I},
{"unset_style",{P}},
{"add_drag_dest",{P,P,I,I,I}},
{"get_drag_item",{P,P},P,0,GtkWidget},
{"get_drop_group",{P,I,I},P,0,GtkToolItemGroup},
{"set_drag_source",{P,I}},
"GtkToolPalette"}
widget[GtkTextView] = {"gtk_text_view",
{GtkScrollable,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{},P},
{"new_with_buffer",{P},P},
{"set_buffer",{P,P}},
{"get_buffer",{P},P,0,GtkTextBuffer},
{"scroll_to_mark",{P,P,D,B,D,D}},
{"scroll_to_iter",{P,P,D,B,D,D},B},
{"scroll_mark_onscreen",{P,P}},
{"place_cursor_onscreen",{P},B},
{"get_visible_rect",{P,P}},
{"get_iter_location",{P,P,P}},
{"get_cursor_locations",{P,P,P,P}},
{"get_line_at_y",{P,P,I,I}},
{"get_line_yrange",{P,P,I,I}},
{"get_iter_at_location",{P,P,I,I}},
{"get_iter_at_position",{P,P,I,I,I}},
{"buffer_to_window_coords",{P,P,I,I,I,I}},
{"window_to_buffer_coords",{P,P,I,I,I,I}},
{"get_window",{P,I},P,0,GdkWindow},
{"set_border_window_size",{P,I,I}},
{"get_border_window_size",{P,P},I},
{"forward_display_line",{P,P},B},
{"backward_display_line",{P,P},B},
{"forward_display_line_end",{P,P},B},
{"backward_display_line_start",{P,P},B},
{"starts_display_line",{P,P},B},
{"move_visually",{P,P,I},B},
{"add_child_at_anchor",{P,P,P}},
{"add_child_in_window",{P,P,P,I,I}},
{"move_child",{P,P,I,I}},
{"set_wrap_mode",{P,I}},
{"get_wrap_mode",{P},I},
{"set_editable",{P,B}},
{"get_editable",{P},B},
{"set_cursor_visible",{P,B}},
{"get_cursor_visible",{P},B},
{"set_overwrite",{P,B}},
{"get_overwrite",{P},B},
{"set_pixels_above_lines",{P,I}},
{"get_pixels_above_lines",{P},I},
{"set_pixels_below_lines",{P,I}},
{"get_pixels_below_lines",{P},I},
{"set_pixels_inside_wrap",{P,I}},
{"get_pixels_inside_wrap",{P},I},
{"set_justification",{P,I}},
{"get_justification",{P},I},
{"set_left_margin",{P,I}},
{"get_left_margin",{P},I},
{"set_right_margin",{P,I}},
{"get_right_margin",{P},I},
{"set_indent",{P,I}},
{"get_indent",{P},I},
{"set_tabs",{P,A}},
{"get_tabs",{P},A,0,PangoTabArray},
{"set_accepts_tab",{P,B}},
{"get_accepts_tab",{P},B},
{"im_context_filter_keypress",{P,P},B},
{"get_default_attributes",{P},P,0,GtkTextAttributes},
{"reset_im_context",{P}},
{"set_input_purpose",{P,I}}, -- 3.6+
{"get_input_purpose",{P},I}, -- 3.6+
{"set_input_hints",{P,I}}, -- 3.6+
{"get_input_hints",{P},I}, -- 3.6+
{"get_monospace",{P},B}, -- 3.16
{"set_monospace",{P,B}}, -- 3.16
{"get_bottom_margin",{P},I}, -- 3.18
{"set_bottom_margin",{P,I}}, -- 3.18
{"get_top_margin",{P},I}, -- 3.18
{"set_top_margin",{P,I}}, -- 3.18
{"reset_cursor_blink",{P}}, -- 3.20
"GtkTextView"}
widget[GtkToolShell] = {"gtk_tool_shell", -- WARNING!
{GtkWidget}, -- see GTK3 docs re: GtkToolShell functions
{"get_ellipsize_mode",{P},I},
{"get_icon_size",{P},I},
{"get_orientation",{P},I},
{"get_relief_style",{P},I},
{"get_style",{P},I},
{"get_text_alignment",{P},F},
{"get_text_orientation",{P},I},
{"get_text_size_group",{P},P,0,GtkSizeGroup},
{"rebuild_menu",{P}},
"GtkToolShell"}
widget[GtkToolbar] = {"gtk_toolbar",
{GtkToolShell,GtkContainer,GtkWidget,GtkOrientable,GtkBuildable,GObject},
{"new",{},P},
{"insert",{P,P,I}},
{"get_item_index",{P,P},I},
{"get_n_items",{P},I},
{"get_nth_item",{P},P},
{"get_drop_index",{P,I,I},I},
{"set_drop_highlight_item",{P,P,I}},
{"set_show_arrow",{P,B}},
{"get_show_arrow",{P},B},
{"set_icon_size",{P,I}},
{"get_icon_size",{P},I},
{"unset_icon_size",{P}},
{"set_style",{P,I}},
{"get_style",{P},I},
{"unset_style",{P}},
"GtkToolbar"}
widget[GtkToolItemGroup] = {"gtk_tool_item_group",
{GtkToolShell,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{S},P},
{"set_collapsed",{P,B}},
{"get_collapsed",{P},B},
{"set_ellipsize",{P,I}},
{"get_ellipsize",{P},I},
{"get_drop_item",{P,I,I},P,0,GtkToolItem},
{"get_n_items",{P},I},
{"get_nth_item",{P,I},P,0,GtkToolItem},
{"set_label",{P,S}},
{"get_label",{P},S},
{"set_label_widget",{P,P}},
{"get_label_widget",{P},P,0,GtkWidget},
{"set_header_relief",{P,I}},
{"get_header_relief",{P},I},
{"insert",{P,P,I}},
{"set_item_position",{P,P,I}},
"GtkToolItemGroup"}
widget[GtkTooltip] = {"gtk_tooltip",
{GObject},
{"set_text",{P,S}},
{"set_markup",{P,S}},
{"set_icon",{P,P}},
{"set_icon_from_icon_name",{P,S,I}},
{"set_icon_from_gicon",{P,P,I}},
{"set_custom",{P,P}},
{"trigger_tooltip_query",{P}},
{"set_tip_area",{P,P}},
"GtkTooltip"}
function newColumn(object params)
params = keyvalues(params)
atom c = create(GtkTreeViewColumn)
atom r = -1
object t = vlookup("type",params,1,2)
switch t do
case "text","markup" then r = create(GtkCellRendererText)
case "pixbuf" then r = create(GtkCellRendererPixbuf)
case "progress" then r = create(GtkCellRendererProgress)
case "spin" then r = create(GtkCellRendererSpin)
case "toggle" then r = create(GtkCellRendererToggle)
case "combo" then r = create(GtkCellRendererCombo)
case else display("Error specifying cell renderer type")
end switch
if r = -1 then
Warn(,,"Create new column","Must specify a renderer type (i.e. type=text)")
abort(1)
end if
set(c,{{"pack start",r,TRUE}})
for i = 1 to length(params) do
if equal("TRUE",params[i][2]) then params[i][2] = 1 end if
if equal("FALSE",params[i][2]) then params[i][2] = 0 end if
if equal("1",params[i][2]) then params[i][2] = 1 end if
if equal("0",params[i][2]) then params[i][2] = 0 end if
if match("column.",params[i][1]) then
set(c,params[i][1][8..$],params[i][2])
elsif match("renderer.",params[i][1]) then
set(r,params[i][1][10..$],params[i][2])
elsif equal("cell_data_func",params[i][1]) then
params[i][2] = to_number(params[i][2])
set(c,"cell data func",r,params[i][2])
else
switch params[i][1] do
case "type" then break -- do nothing
case "title","sort_column_id" then set(c,params[i][1],params[i][2])
case "toggled" then connect(r,"toggled",_(params[i][2]))
case "edited" then connect(r,"edited",_(params[i][2]))
--display("Connecting [] []",{params[i][2],_(params[i][2])})
case else set(c,"add attribute",r,params[i][1],params[i][2])
end switch
end if
end for
set(c,"data","renderer",sprintf("%d",r))
return c
end function
widget[GtkTreeView] = {"gtk_tree_view",
{GtkContainer,GtkWidget,GtkBuildable,GtkScrollable,GObject},
{"new",{P},-routine_id("newTreeView")},
{"set_model",{P,P}},
{"get_model",{P},P,0,GtkTreeModel},
{"get_selection",{P},P,0,GtkTreeSelection},
{"set_headers_visible",{P,B}},
{"get_headers_visible",{P},B},
{"set_headers_clickable",{P,B}},
{"get_headers_clickable",{P},B},
{"set_show_expanders",{P,B}},
{"get_show_expanders",{P},B},
{"set_expander_column",{P,P}},
{"get_expander_column",{P},P,0,GtkTreeViewColumn},
{"set_level_indentation",{P,I}},
{"get_level_indentation",{P},I},
{"columns_autosize",{P}},
{"set_rules_hint",{P,B}}, -- deprecated 3.14
{"get_rules_hint",{P},B}, -- deprecated 3.14
{"set_activate_on_single_click",{P,B}}, -- GTK 3.8+
{"get_activate_on_single_click",{P},B}, -- GTK 3.8+
{"append_column",{P,P},I},
{"append_columns",{P,P},-routine_id("tv_append_columns")},
{"remove_column",{P,P,I}},
{"insert_column",{P,P,I}},
{"insert_column_with_attributes",{P,I,S,S,I,I}},
{"insert_column_with_data_func",{P,I,S,P,P,P,P}},
{"get_n_columns",{P},I},
{"get_column",{P,I},P,0,GtkTreeViewColumn},
{"get_columns",{P},X,0,GList},
{"move_column_after",{P,P,P}},
{"set_column_drag_function",{P,P,P,P}},
{"scroll_to_point",{P,I,I}},
{"scroll_to_cell",{P,P,P,P,F,F},-routine_id("tv_scroll_to_cell")},
{"set_cursor",{P,P,P,B}},
{"set_cursor_on_cell",{P,P,P,P,B}},
{"get_cursor",{P,P,P}},
{"row_activated",{P,P,P}},
{"expand_row",{P,P,B},B},
{"expand_all",{P}},
{"expand_to_path",{P,P}},
{"collapse_all",{P}},
{"map_expanded_rows",{P,P,P}},
{"row_expanded",{P,P},B},
{"set_reorderable",{P,B}},
{"get_reorderable",{P,B}},
{"get_path_at_pos",{P,I,I,P,P,I,I},B},
{"is_blank_at_pos",{P,I,I,P,P,I,I},B},
{"get_cell_area",{P,P,P,P}},
{"get_background_area",{P,P,P,P}},
{"get_visible_rect",{P,P}},
{"get_visible_range",{P,P,P},B},
{"get_bin_window",{P},P,0,GdkWindow},
{"convert_bin_window_to_tree_coords",{P,I,I,I,I}},
{"convert_bin_window_to_widget_coords",{P,I,I,I,I}},
{"convert_tree_to_bin_window_coords",{P,I,I,I,I}},
{"convert_tree_to_widget_coords",{P,I,I,I,I}},
{"convert_widget_to_bin_window_coords",{P,I,I,I,I}},
{"convert_widget_to_tree_coords",{P,I,I,I,I}},
{"enable_model_drag_dest",{P,P,I,I}},
{"enable_model_drag_source",{P,I,P,I,I}},
{"unset_rows_drag_source",{P}},
{"unset_rows_drag_dest",{P}},
{"set_drag_dest_row",{P,P,I}},
{"get_drag_dest_row",{P,P,P}},
{"get_drag_dest_row_at_pos",{P,I,I,P,P},B},
{"create_row_drag_icon",{P,P},P,0,CairoSurface_t},
{"set_enable_search",{P,B}},
{"get_enable_search",{P},B},
{"set_search_column",{P,I}},
{"get_search_column",{P},I},
{"set_search_equal_func",{P,P,P,P}},
{"get_search_equal_func",{P},P},
{"set_search_entry",{P,P}},
{"get_search_entry",{P},P,0,GtkEntry},
{"set_search_position_func",{P,P,P,P}},
{"get_search_position_func",{P},P},
{"set_fixed_height_mode",{P,B}},
{"get_fixed_height_mode",{P},B},
{"set_hover_selection",{P,B}},
{"get_hover_selection",{P},B},
{"set_hover_expand",{P,B}},
{"get_hover_expand",{P},B},
{"set_destroy_count_func",{P,P,P,P}},
{"set_row_separator_func",{P,P,P,P}},
{"get_row_separator_func",{P},P},
{"set_rubber_banding",{P,B}},
{"get_rubber_banding",{P},B},
{"set_enable_tree_lines",{P,B}},
{"get_enable_tree_lines",{P},B},
{"set_grid_lines",{P,B}},
{"get_grid_lines",{P},B},
{"set_tooltip_row",{P,P,P}},
{"set_tooltip_cell",{P,P,P,P,P}},
{"set_tooltip_column",{P,I}},
{"get_tooltip_column",{P},I},
{"get_tooltip_context",{P,I,I,B,P,P,P},B},
{"select_row",{P,P,D,D},-routine_id("tv_select_row")},
{"get_selected_row_data",{P,P},-routine_id("tv_get_selected_row_data")},
{"get_selected_col_data",{P,P,I},-routine_id("tv_get_selected_col_data")},
"GtkTreeView"}
function newTreeView(atom x=0)
if class_id(x) = GtkTreeModel then
return gtk_func("gtk_tree_view_new_with_model",{P},{x})
else
return gtk_func("gtk_tree_view_new")
end if
end function
constant sfn1 = define_func("gtk_tree_view_get_model",{P},P)
constant sfn2 = define_func("gtk_tree_model_get_n_columns",{P},I)
constant sfn3 = define_func("gtk_tree_model_get_iter",{P,P,P},B)
constant sfn4 = define_func("gtk_tree_model_get_column_type",{P,I},I)
constant sp1 = define_proc("gtk_tree_model_get",{P,P,I,P,I})
function tv_get_selected_col_data(atom view, atom path, integer col)
object data = tv_get_selected_row_data(view,path)
return data[col]
end function
function tv_get_selected_row_data(atom view, atom path)
atom mdl = c_func(sfn1,{view})
integer ncols = c_func(sfn2,{mdl})
object data = repeat(0,ncols)
object types = repeat(0,ncols)
atom iter = allocate(32,1)
object result
if c_func(sfn3,{mdl,iter,path}) then
for i = 1 to length(data) do
data[i] = allocate(32,1)
types[i] = c_func(sfn4,{mdl,i-1})
c_proc(sp1,{mdl,iter,i-1,data[i],-1})
end for
end if
for i = 1 to length(data) do
switch types[i] do
case gSTR then
ifdef BITS64 then -- thanks pete eberlein
result = peek8u(data[i])
elsedef
result = peek4u(data[i])
end ifdef
if result > 0 then
result = peek_string(result)
end if
data[i] = result
case else data[i] = peek4u(data[i])
end switch
end for
return data
end function
function tv_scroll_to_cell(atom v, atom p, atom c=0, integer align=0, atom row=0, atom col=0)
gtk_proc("gtk_tree_view_scroll_to_cell",{P,P,P,I,F,F},{v,p,c,align,row,col})
return 1
end function
function tv_append_columns(atom store, object cols)
if atom(cols) then
gtk_func("gtk_tree_view_append_column",{P,P},{store,cols})
else
for i = 1 to length(cols) do
tv_append_columns(store,cols[i])
end for
end if
return 1
end function
function tv_select_row(atom tv, object path, atom rowalign=0, atom colalign=0)
path = create(GtkTreePath,path)
gtk_func("gtk_tree_view_scroll_to_cell",
{P,P,I,I,F,F},{tv,path,0,1,rowalign,colalign})
return 1
end function
widget[GtkTreeViewColumn] = {"gtk_tree_view_column",
{GtkCellLayout,GtkBuildable,GObject},
{"new",{},P},
{"set_title",{P,S}},
{"get_title",{P},S},
{"pack_start",{P,P,B}},
{"pack_end",{P,P,B}},
{"clear",{P}},
{"clicked",{P}},
{"add_attribute",{P,P,S,I}},
{"set_spacing",{P,I}},
{"get_spacing",{P},I},
{"set_visible",{P,B}},
{"get_visible",{P},B},
{"set_resizable",{P,B}},
{"get_resizable",{P},B},
{"set_sizing",{P,I}},
{"get_sizing",{P},I},
{"set_fixed_width",{P,I}},
{"get_fixed_width",{P},I},
{"set_min_width",{P,I}},
{"get_min_width",{P},I},
{"set_max_width",{P,I}},
{"get_max_width",{P},I},
{"set_expand",{P,B}},
{"get_expand",{P},B},
{"set_clickable",{P,B}},
{"get_clickable",{P},B},
{"set_widget",{P,P}},
{"get_widget",{P},P},
{"get_button",{P},P,0,GtkWidget},
{"set_alignment",{P,F}},
{"get_alignment",{P},F},
{"set_reorderable",{P,B}},
{"get_reorderable",{P},B},
{"set_sort_column_id",{P,I}},
{"get_sort_column_id",{P},I},
{"set_sort_indicator",{P,B}},
{"get_sort_indicator",{P},B},
{"set_sort_order",{P,I}},
{"get_sort_order",{P},I},
{"cell_set_cell_data",{P,P,P,B,B}},
{"cell_get_size",{P,P,I,I,I,I}},
{"cell_get_position",{P,P,I,I},B},
{"cell_is_visible",{P},B},
{"focus_cell",{P,P}},
{"queue_resize",{P}},
{"get_tree_view",{P},P,0,GtkTreeView},
{"get_x_offset",{P},I},
"GtkTreeViewColumn"}
widget[GtkTreeSelection] = {"gtk_tree_selection",
{GObject},
{"set_mode",{P,I}},
{"get_mode",{P},I},
{"set_select_function",{P,P,P,P}},
{"get_select_function",{P},P},
{"get_user_data",{P},P},
{"get_tree_view",{P},P},
{"get_selected",{P,P,P},B},
{"selected_foreach",{P,P,P}},
{"count_selected_rows",{P},I},
{"select_path",{P,P}},
{"unselect_path",{P,P}},
{"path_is_selected",{P,P},B},
{"select_iter",{P,P}},
{"unselect_iter",{P,P}},
{"iter_is_selected",{P,P},B},
{"select_all",{P}},
{"unselect_all",{P}},
{"select_range",{P,P,P}},
{"unselect_range",{P,P,P}},
{"get_selected_row",{P,P},-routine_id("ts_get_selected_row")},
{"get_selected_rows",{P,P},-routine_id("ts_get_selected_rows")},
{"get_selected_row_data",{P},-routine_id("ts_get_selected_row_data")},
"GtkTreeSelection"}
function ts_get_selected_rows(atom selection, atom model)
object list = gtk_func("gtk_tree_selection_get_selected_rows",
{P,P},{selection,model})
list = to_sequence(list,3)
return list +1
end function
function ts_get_selected_row(atom selection, atom model)
object result = ts_get_selected_rows(selection,model)
if equal({},result) then return 0
else return result[1]
end if
end function
function ts_get_selected_row_data(atom selection)
atom mdl = allocate(32), iter = allocate(32)
integer n
object x,t, val, result
if gtk_func("gtk_tree_selection_get_selected",{P,P,P},{selection,mdl,iter}) then
mdl = peek4u(mdl)
n = gtk_func("gtk_tree_model_get_n_columns",{P},{mdl})
x = repeat(0,n) t = x
for i = 1 to n do
val = allocate(32,1)
gtk_proc("gtk_tree_model_get",{P,P,I,P,I},{mdl,iter,i-1,val,-1})
t[i] = gtk_func("gtk_tree_model_get_column_type",{P,I},{mdl,i-1})
x[i] = val
end for
for i = 1 to length(x) do
switch t[i] do
case gSTR then
ifdef BITS64 then -- thanks pete eberlein
result = peek8u(x[i])
elsedef
result = peek4u(x[i])
end ifdef
if result > 0 then
x[i] = peek_string(result)
end if
case gFLT then x[i] = float32_to_atom(peek({x[i],4}))
case gDBL then x[i] = float64_to_atom(peek({x[i],8}))
case else x[i] = peek4u(x[i])
end switch
end for
return x
end if
return -1
end function
widget[GtkActionBar] = {"gtk_action_bar", -- GTK 3.12
{GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{},P},
{"pack_start",{P,P}},
{"pack_end",{P,P}},
{"get_center_widget",{P},P},
{"set_center_widget",{P,P}},
"GtkActionBar"}
widget[GtkAccelLabel] = {"gtk_accel_label",
{GtkLabel,GtkMisc,GtkWidget,GtkBuildable,GObject},
{"new",{S},P},
{"get_accel",{P,I,I}}, -- 3.14
{"set_accel",{P,I,I}},
{"set_accel_closure",{P,P}},
{"set_accel_widget",{P,P}},
{"get_accel_widget",{P},P,0,GtkWidget},
{"get_accel_width",{P},I},
{"refetch",{P},B},
"GtkAccelLabel"}
widget[GtkAccelGroup] = {"gtk_accel_group",
{GObject},
{"new",{},P},
{"connect",{P,I,I,I,P}},
{"connect_by_path",{P,S,P}},
{"disconnect",{P,P},B},
{"disconnect_key",{P,I,I},B},
{"activate",{P,I,P,I,I},B},
{"lock",{P}},
{"unlock",{P}},
{"get_is_locked",{P},B},
{"from_accel_closure",{P},P,0,GtkAccelGroup},
{"get_modifier_mask",{P},I},
{"find",{P,P,P},P},
"GtkAccelGroup"}
widget[GtkArrow] = {"gtk_arrow", -- deprecated 3.14
{GtkMisc,GtkWidget,GtkBuildable,GObject},
{"new",{I,I},P},
{"set",{P,I,I}},
"GtkArrow"}
widget[GtkCalendar] = {"gtk_calendar",
{GtkWidget,GtkBuildable,GObject},
{"clear_marks",{P}},
{"get_date",{P,I},-routine_id("cal_get_date")},
{"get_ymd",{P,I},-routine_id("cal_get_ymd")},
{"get_eu_date",{P},-routine_id("cal_get_eu_date")},
{"get_day",{P},-routine_id("cal_get_day")},
{"get_month",{P},-routine_id("cal_get_month")},
{"get_year",{P},-routine_id("cal_get_year")},
{"get_datetime",{P,I},-routine_id("cal_get_datetime")},
{"get_day_is_marked",{P,I},B},
{"get_display_options",{P},I},
{"mark_day",{P,I},B},
{"new",{P},-routine_id("newCalendar")},
{"select_day",{P,I}},
{"select_month",{P,I,I},-routine_id("cal_select_month")},
{"set_display_options",{P,I}},
{"unmark_day",{P,I},B},
{"set_detail_func",{P,P,P,P}},
{"set_detail_width_chars",{P,I}},
{"get_detail_width_chars",{P},I},
{"get_detail_height_rows",{P},I},
{"set_detail_height_rows",{P,I}},
{"set_date",{P,P},-routine_id("cal_set_date")},
{"set_eu_date",{P,P},-routine_id("cal_set_date")},
{"set_day",{P,I},-routine_id("cal_set_day")},
{"set_month",{P,I},-routine_id("cal_set_month")},
{"set_year",{P,I},-routine_id("cal_set_year")},
"GtkCalendar"}
function newCalendar(object d = 0) -- create calendar, set optional date;
object cal = gtk_func("gtk_calendar_new")
if atom(d) and d = 0 then return cal
else gtk_proc("gtk_calendar_select_month",{P,I,I},{cal,d[2]-1,d[1]})
gtk_proc("gtk_calendar_select_day",{P,I},{cal,d[3]})
return cal
end if
end function
------------------------------------------------------------------------
-- Calendar convenience functions
------------------------------------------------------------------------
-- Handle odd month numbering scheme:
-- Q: If the first day of the month is 1, then why is the first month
-- of the year zero
-- A: Blame a C programmer!
-- Here we fix that, plus change the set_date routine from two steps
-- to one; also, provide for standard formatting to be used when
-- getting the date. See std/datetime.e for the formats available.
------------------------------------------------------------------------
constant get_date = define_proc("gtk_calendar_get_date",{P,I,I,I})
function cal_select_month(atom handle, integer mo, integer yr=0)
while mo < 1 do yr -= 1 mo += 12 end while
while mo > 12 do yr += 1 mo -= 12 end while
gtk_proc("gtk_calendar_select_month",{P,I,I},{handle,mo-1,yr})
return 1
end function
function cal_set_day(atom handle, integer day)
object curr = get(handle,"date")
curr[3] = day
cal_set_date(handle,curr)
return 1
end function
function cal_set_month(atom handle, integer month)
object curr = get(handle,"date")
curr[2] = month
cal_set_date(handle,curr)
return 1
end function
function cal_set_year(atom handle, integer year)
object curr = get(handle,"date")
curr[1] = year
cal_set_date(handle,curr)
return 1
end function
function cal_set_date(atom handle, object cdate)
object dt = 0
integer yr, mo, da
dt = datetime:parse(cdate,"%Y/%m/%d")
if atom(dt) then
dt = datetime:parse(cdate,"%Y,%m,%d")
end if
if atom(dt) then
dt = datetime:parse(cdate,"%m/%d/%y")
end if
if atom(dt) then
dt = datetime:parse(cdate,"%m/%d/%Y")
end if
if atom(dt) then
dt = datetime:parse(cdate,"%y/%m/%d")
end if
if atom(dt) then
if cdate[1] > 31 then -- Y/M/D
yr = cdate[1]
mo = cdate[2]
da = cdate[3]
end if
if cdate[3] > 31 then -- M/D/Y
mo = cdate[1]
da = cdate[2]
yr = cdate[3]
end if
else
yr = dt[1]
mo = dt[2]
da = dt[3]
end if
if yr < 1900 then yr += 1900 end if
gtk_proc("gtk_calendar_select_month",{P,I,I},{handle,mo-1,yr})
gtk_proc("gtk_calendar_select_day",{P,I},{handle,da})
return 1
end function
function setCalendarEuDate(atom handle, object edt)
edt[1] += 1900
return cal_set_date(handle,edt)
end function
function cal_get_date(atom handle, object fmt=0)
atom y = allocate(8,1), m = allocate(8,1), d = allocate(8,1)
object clock
if atom(fmt) and fmt = 0 then
fmt = "%A, %b %d, %Y"
else
fmt = peek_string(fmt)
end if
object result
c_proc(get_date,{handle,y,m,d})
result = datetime:new(peek4u(y),peek4u(m)+1,peek4u(d))
clock = datetime:now()
result = result[1..3] & clock[4..6]
result = datetime:format(result,fmt)
return result
end function
function cal_get_datetime(atom handle, object fmt=1)
atom y = allocate(8,1), m = allocate(8,1), d = allocate(8,1)
object result
c_proc(get_date,{handle,y,m,d})
result = datetime:now() -- for current hr,min,sec
result[1] = peek4u(y)
result[2] = peek4u(m)+1
result[3] = peek4u(d)
if fmt = 0 then -- set hr,min,sec to zero;
result[4] = 0
result[5] = 0
result[6] = 0
end if
return result
end function
function cal_get_eu_date(atom handle) --returns {y,m,d} in Eu fmt.
atom y = allocate(8,1), m = allocate(8,1), d = allocate(8,1)
c_proc(get_date,{handle,y,m,d})
sequence result = {peek4u(y)-1900,peek4u(m)+1,peek4u(d)}
return result
end function
function cal_get_ymd(atom handle, integer full=0)
object clock
switch full do
case 0 then return cal_get_eu_date(handle) + {1900,0,0}
case 1 then return cal_get_eu_date(handle) + {1900,0,0} & {0,0,0}
case 2 then clock = datetime:now()
return cal_get_eu_date(handle) + {1900,0,0} & clock[4..6]
case else return cal_get_eu_date(handle) + {1900,0,0}
end switch
end function
function cal_get_day(atom handle)
atom y = allocate(8,1), m = allocate(8,1), d = allocate(8,1)
c_proc(get_date,{handle,y,m,d})
integer result = peek4u(d)
return result
end function
function cal_get_month(atom handle)
atom y = allocate(8,1), m = allocate(8,1), d = allocate(8,1)
c_proc(get_date,{handle,y,m,d})
integer result = peek4u(m)
return result+1
end function
function cal_get_year(atom handle)
atom y = allocate(8,1), m = allocate(8,1), d = allocate(8,1)
c_proc(get_date,{handle,y,m,d})
integer result = peek4u(y)
return result
end function
widget[GtkCellView] = {"gtk_cell_view",
{GtkCellLayout,GtkWidget,GtkBuildable,GtkOrientable,GObject},
{"new",{P,P},-routine_id("newCellView")},
{"set_model",{P,P}},
{"get_model",{P},P},
{"set_displayed_row",{P,P}},
{"get_displayed_row",{P},P,0,GtkTreePath},
{"set_draw_sensitive",{P,B}},
{"get_draw_sensitive",{P},B},
{"set_fit_model",{P,B}},
{"get_fit_model",{P},B},
"GtkCellView"}
function newCellView(atom x=0, atom y=0)
if class_id(x) = GtkCellArea
and class_id(y) = GtkCellAreaContext then
return gtk_func("gtk_cell_view_new_with_context",{P,P},{x,y})
elsif atom(x) and x > 0 then
if class_id(x) = GdkPixbuf then
return gtk_func("gtk_cell_view_new_with_pixbuf",{P},{x})
end if
elsif string(x) then
return gtk_func("gtk_cell_view_new_with_markup",{P},{allocate_string(x)})
end if
end function
widget[GtkDrawingArea] = {"gtk_drawing_area",
{GtkWidget,GtkBuildable,GObject},
{"new",{},P},
"GtkDrawingArea"}
widget[GtkSearchEntry] = {"gtk_search_entry", --3.6
{GtkEntry,GtkWidget,GtkBuildable,GtkEditable,GtkCellEditable,GObject},
{"new",{},P},
{"handle_event",{P,P},B},
"GtkSearchEntry"}
widget[GtkEntryBuffer] = {"gtk_entry_buffer",
{GObject},
{"new",{S,I},P},
{"get_text",{P},S},
{"set_text",{P,S,I}},
{"get_bytes",{P},I},
{"get_length",{P},I},
{"set_max_length",{P,I}},
{"get_max_length",{P},I},
{"insert_text",{P,I,S,I},I},
{"delete_text",{P,I,I},I},
{"emit_deleted_text",{P,I,I}},
{"emit_inserted_text",{P,I,S,I}},
"GtkEntryBuffer"}
widget[GtkEntryCompletion] = {"gtk_entry_completion",
{GtkCellLayout,GtkBuildable,GObject},
{"new",{P},-routine_id("newEntryCompletion")},
{"get_entry",{P},P,0,GtkEntry},
{"set_model",{P,P}},
{"get_model",{P},P,0,GtkTreeModel},
{"set_match_func",{P,P,P,P}},
{"set_minimum_key_length",{P,I}},
{"get_minimum_key_length",{P},I},
{"compute_prefix",{P,S},S},
{"get_completion_prefix",{P},S},
{"insert_prefix",{P}},
{"insert_action_text",{P,I,S}},
{"insert_action_markup",{P,I,S}},
{"delete_action",{P,I}},
{"set_text_column",{P,I}},
{"get_text_column",{P},I},
{"set_inline_completion",{P,B}},
{"get_inline_completion",{P},B},
{"set_inline_selection",{P,B}},
{"get_inline_selection",{P},B},
{"set_popup_completion",{P,B}},
{"get_popup_completion",{P},B},
{"set_popup_set_width",{P,B}},
{"get_popup_set_width",{P},B},
{"set_popup_single_match",{P,B}},
{"get_popup_single_match",{P},B},
{"complete",{P}},
"GtkEntryCompletion"}
function newEntryCompletion(atom x=0)
if class_id(x) = GtkCellArea then
return gtk_func("gtk_entry_completion_new_with_area",{P},{x})
else
return gtk_func("gtk_entry_completion_new")
end if
end function
widget[GtkRevealer] = {"gtk_revealer", -- new in GTK 3.10
{GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{},P},
{"set_reveal_child",{P,B}},
{"get_reveal_child",{P},B},
{"get_child_revealed",{P},B},
{"set_transition_duration",{P,I}},
{"get_transition_duration",{P},I},
{"set_transition_type",{P,I}},
{"get_transition_type",{P},I},
"GtkRevealer"}
widget[GtkSearchBar] = {"gtk_search_bar", -- new in GTK 3.10
{GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{},P},
{"connect_entry",{P,P}},
{"set_search_mode",{P,B}},
{"get_search_mode",{P},B},
{"set_show_close_button",{P,B}},
{"get_show_close_button",{P},B},
{"handle_event",{P,P},B},
"GtkSearchBar"}
widget[GtkStack] = {"gtk_stack", -- new in GTK 3.10
{GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{},P},
{"add_named",{P,P,S}},
{"add_titled",{P,P,S,S}},
{"set_visible_child",{P,P}},
{"get_visible_child",{P},P,0,GtkWidget},
{"set_visible_child_name",{P,S}},
{"get_visible_child_name",{P},S},
{"set_visible_child_full",{P,S,I}},
{"set_homogeneous",{P,B}},
{"get_homogeneous",{P},B},
{"set_transition_duration",{P,I}},
{"get_transition_duration",{P},I},
{"set_transition_type",{P,I}},
{"get_transition_type",{P},I},
{"get_child_by_name",{P,S},P,0,GtkWidget}, -- 3.12
{"get_transition_running",{P},B}, -- 3.12
{"get_hhomogeneous",{P},B}, -- 3.16
{"set_hhomogeneous",{P,B}}, -- 3.16
{"get_vhomogeneous",{P},B}, -- 3.16
{"set_vhomogeneous",{P,B}}, -- 3.16
{"get_interpolate_size",{P},B}, -- 3.18
{"set_interpolate_size",{P,B}}, -- 3.18
"GtkStack"}
widget[GtkStackSidebar] = {"gtk_stack_sidebar", -- 3.16
{GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{},P},
{"set_stack",{P,P}},
{"get_stack",{P},P,0,GtkStack},
"GtkStackSidebar"}
widget[GtkStackSwitcher] = {"gtk_stack_switcher",
{GtkBox,GtkContainer,GtkWidget,GtkBuildable,GtkOrientable,GObject},
{"new",{},P},
{"set_stack",{P,P}},
{"get_stack",{P},P,0,GtkStack},
"GtkStackSwitcher"}
widget[GtkScrollbar] = {"gtk_scrollbar",
{GtkRange,GtkWidget,GtkBuildable,GtkOrientable,GObject},
{"new",{I,P},P},
"GtkScrollbar"}
widget[GtkInvisible] = {"gtk_invisible",
{GtkWidget,GtkBuildable,GObject},
{"new",{P},-routine_id("newInvisible")},
{"set_screen",{P,P}},
{"get_screen",{P},P,0,GdkScreen},
"GtkInvisible"}
function newInvisible(atom x=0)
if class_id(x) = GdkScreen then
return gtk_func("gtk_invisible_new_for_screen",{P},{x})
else
return gtk_func("gtk_invisible_new")
end if
end function
widget[GtkProgressBar] = {"gtk_progress_bar",
{GtkWidget,GtkBuildable,GtkOrientable,GObject},
{"new",{},P},
{"pulse",{P}},
{"set_fraction",{P,D}},
{"get_fraction",{P},D},
{"set_inverted",{P,B}},
{"get_inverted",{P},B},
{"set_show_text",{P,B}},
{"get_show_text",{P},B},
{"set_text",{P,S}},
{"get_text",{P},S},
{"set_ellipsize",{P,B}},
{"get_ellipsize",{P},B},
{"set_pulse_step",{P,D}},
{"get_pulse_step",{P},D},
"GtkProgressBar"}
widget[GtkSpinner] = {"gtk_spinner",
{GtkWidget,GtkBuildable,GObject},
{"new",{},P},
{"start",{P}},
{"stop",{P}},
"GtkSpinner"}
widget[GtkSwitch] = {"gtk_switch",
{GtkWidget,GtkBuildable,GtkActionable,GObject},
{"new",{},P},
{"set_active",{P,B}},
{"get_active",{P},B},
{"get_state",{P},B}, -- GTK3.14
{"set_state",{P,B}}, -- GTK3.14
"GtkSwitch"}
widget[GtkLevelBar] = {"gtk_level_bar",-- GTK3.6+
{GtkWidget,GtkBuildable,GtkBuildable,GtkOrientable,GObject},
{"new",{D,D},-routine_id("newLevelBar")},
{"new_for_interval",{D,D},P},
{"set_mode",{P,I}},
{"get_mode",{P},I},
{"set_value",{P,D}},
{"get_value",{P},D},
{"set_min_value",{P,D}},
{"get_min_value",{P},D},
{"set_max_value",{P,D}},
{"get_max_value",{P},D},
{"add_offset_value",{P,S,D}},
{"remove_offset_value",{P,S}},
{"get_offset_value",{P,S},D},
{"get_inverted",{P},B}, --GTK3.8+
{"set_inverted",{P,B}}, --GTK3.8+
"GtkLevelBar"}
function newLevelBar(atom x=0, atom y=0)
if x+y > 0 then
return gtk_func("gtk_level_bar_new_for_interval",{D,D},{x,y})
else
return gtk_func("gtk_level_bar_new")
end if
end function
widget[GtkAboutDialog] = {"gtk_about_dialog",
{GtkDialog,GtkWindow,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{},P},
{"set_program_name",{P,S}},
{"get_program_name",{P},S},
{"set_version",{P,S}},
{"get_version",{P},S},
{"set_copyright",{P,S}},
{"get_copyright",{P},S},
{"set_comments",{P,S}},
{"get_comments",{P},S},
{"set_license",{P,S}},
{"get_license",{P},S},
{"set_wrap_license",{P,B}},
{"get_wrap_license",{P},B},
{"set_license_type",{P,I}},
{"get_license_type",{P},I},
{"set_website",{P,S}},
{"get_website",{P},S},
{"set_website_label",{P,S}},
{"get_website_label",{P},S},
{"set_authors",{P,A}},
{"get_authors",{P},V},
{"set_artists",{P,A}},
{"get_artists",{P},V},
{"set_documenters",{P,A}},
{"get_documenters",{P},V},
{"set_translator_credits",{P,S}},
{"get_translator_credits",{P},S},
{"set_logo",{P,P},-routine_id("setAboutLogo")},
{"get_logo",{P},P,0,GdkPixbuf},
{"set_logo_icon_name",{P,S}},
{"get_logo_icon_name",{P},S},
{"add_credit_section",{P,S,A}},
"GtkAboutDialog"}
function setAboutLogo(atom dlg, object logo)
if string(logo) then
logo = locate_file(logo)
if file_type(logo) = 0 then return 0 end if
end if
if atom(logo) and class_id(logo) = GdkPixbuf then
return 0
else
logo = create(GdkPixbuf,logo)
end if
gtk_proc("gtk_about_dialog_set_logo",{P,P},{dlg,logo})
return 1
end function
widget[GtkAppChooserDialog] = {"gtk_app_chooser_dialog",
{GtkAppChooser,GtkDialog,GtkWindow,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{P,I,P},-routine_id("newAppChooserDialog")},
{"get_widget",{P},P,0,GtkAppChooserWidget},
{"set_heading",{P,S}},
{"get_heading",{P},S},
"GtkAppChooserDialog"}
function newAppChooserDialog(atom parent, integer flags, object x)
if string(x) and file_exists(canonical_path(x)) then
x = allocate_string(canonical_path(x),1)
x = gtk_func("g_file_new_for_path",{P},{x})
return gtk_func("gtk_app_chooser_dialog_new",{P,I,P},{parent,flags,x})
else
if string(x) then
x = allocate_string(x,1)
end if
return gtk_func("gtk_app_chooser_dialog_new_for_content_type",
{P,I,P},{parent,flags,x})
end if
end function
widget[GtkColorChooserDialog] = {"gtk_color_chooser_dialog",
{GtkColorChooser,GtkDialog,GtkWindow,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{S,P},P},
"GtkColorChooserDialog"}
widget[GtkColorSelectionDialog] = {"gtk_color_selection_dialog",
{GtkDialog,GtkWindow,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{S},P},
{"get_color_selection",{P},P,0,GtkColorSelection},
"GtkColorSelectionDialog"}
widget[GtkFileChooserDialog] = {"gtk_file_chooser_dialog",
{GtkFileChooser,GtkDialog,GtkWindow,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{S,P,I,S},P},
"GtkFileChooserDialog"}
widget[GtkFontChooserDialog] = {"gtk_font_chooser_dialog",
{GtkFontChooser,GtkDialog,GtkWindow,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{S,P},P},
"GtkFontChooserDialog"}
widget[GtkStyleProvider] = {"gtk_style_provider",
{0},
{"get_style_property",{P,P,I,P,P},B},
"GtkStyleProvider"}
widget[GtkStyleContext] = {"gtk_style_context",
{GObject},
{"new",{},P},
{"add_provider",{P,P,I}},
{"add_provider_for_screen",{P,P,P,I},-routine_id("sc_add_provider_for_screen")},
{"get",{P,I,S,P,I}},
{"get_junction_sides",{P},I},
{"get_parent",{P},P,0,GtkStyleContext},
{"get_path",{P},P,0,GtkWidgetPath},
{"get_property",{P,S,I,P}},
{"get_screen",{P},P,0,GdkScreen},
{"get_frame_clock",{P},P,0,GdkFrameClock},
{"get_state",{P},I},
{"get_style",{P,S,P,I}},
{"get_style_property",{P,S,P}},
{"get_section",{P,S},P,0,GtkCssSection},
{"get_color",{P,I,P}},
{"get_background_color",{P,I,P}}, -- deprecated 3.16
{"get_border_color",{P,I,P}}, -- deprecated 3.16
{"get_border",{P,I,P}},
{"get_padding",{P,I,P}},
{"get_margin",{P,I,P}},
{"invalidate",{P}},
{"lookup_color",{P,S,P},B},
{"remove_provider",{P,P}},
{"remove_provider_for_screen",{P,P}},
{"reset_widgets",{P}},
{"set_background",{P,P}},
{"restore",{P}},
{"save",{P}},
{"set_junction_sides",{P,I}},
{"set_parent",{P,P}},
{"set_path",{P,P}},
{"add_class",{P,S}},
{"remove_class",{P,S}},
{"has_class",{P,S},B},
{"list_classes",{P},P,0,GList},
{"add_region",{P,S,I}}, -- deprecated 3.14
{"remove_region",{P,S}}, -- deprecated 3.14
{"has_region",{P,S,I},B}, -- deprecated 3.14
{"list_regions",{P},P,0,GList}, -- deprecated 3.14
{"get_screen",{P,P}},
{"set_frame_clock",{P,P}},
{"set_state",{P,I}},
{"set_scale",{P,I}}, -- 3.10
{"get_scale",{P},I}, -- 3.10
{"to_string",{P,I},S}, -- 3.20
"GtkStyleContext"}
function sc_add_provider_for_screen(atom context, atom scrn, atom pro, integer pri)
gtk_proc("gtk_style_context_add_provider_for_screen",{P,P,I},{scrn,pro,pri})
return 1
end function
widget[GtkRecentChooserDialog] = {"gtk_recent_chooser_dialog",
{GtkRecentChooser,GtkDialog,GtkWindow,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{S,P,P},P},
{"new_for_manager",{S,P,P,P},P},
"GtkRecentChooserDialog"}
widget[GtkPrintSettings] = {"gtk_print_settings",
{GObject},
{"new",{P,P},-routine_id("newPrintSettings")},
{"load_file",{P,S,P},B},
{"to_file",{P,S,P},B},
{"load_key_file",{P,P,S,P},B},
{"to_key_file",{P,P,S}},
{"copy",{P},P,0,GtkPrintSettings},
{"has_key",{P,S},B},
{"get",{P,S},S},
{"set",{P,S,S}},
{"unset",{P,S}},
{"foreach",{P,P,P}},
{"get_bool",{P,S},B},
{"set_bool",{P,S,B}},
{"get_double",{P,S},D},
{"get_double_with_default",{P,S,D},D},
{"set_double",{P,S,D}},
{"get_length",{P,S,I},D},
{"set_length",{P,S,D,I}},
{"get_int",{P,S},I},
{"get_int_with_default",{P,S,I},I},
{"set_int",{P,S,I}},
{"get_printer",{P},S},
{"set_printer",{P,S}},
{"get_orientation",{P},I},
{"set_orientation",{P,I}},
{"get_paper_size",{P},P,0,GtkPaperSize},
{"set_paper_size",{P,P}},
{"get_paper_width",{P,I},D},
{"set_paper_width",{P,D,I}},
{"get_paper_height",{P,I},D},
{"set_paper_height",{P,D,I}},
{"get_use_color",{P},B},
{"set_use_color",{P,B}},
{"get_collate",{P},B},
{"set_collate",{P,B}},
{"get_reverse",{P},B},
{"set_reverse",{P,B}},
{"get_duplex",{P},I},
{"set_duplex",{P,I}},
{"get_quality",{P},I},
{"set_quality",{P,I}},
{"get_n_copies",{P},I},
{"set_n_copies",{P,I}},
{"get_number_up",{P},I},
{"set_number_up",{P,I}},
{"get_number_up_layout",{P},I},
{"set_number_up_layout",{P,I}},
{"get_resolution",{P},I},
{"set_resolution",{P,I}},
{"get_resolution_x",{P},I},
{"get_resolution_y",{P},I},
{"get_printer_lpi",{P},D},
{"set_printer_lpi",{P,D}},
{"get_scale",{P},D},
{"set_scale",{P,D}},
{"get_print_pages",{P},I},
{"set_print_pages",{P,I}},
{"get_page_ranges",{P,I},P,0,GtkPageRange},
{"set_page_ranges",{P,P},-routine_id("ps_set_page_ranges")},
{"get_page_set",{P},I},
{"set_page_set",{P,I}},
{"get_default_source",{P},S},
{"set_default_source",{P,S}},
{"get_media_type",{P},S},
{"set_media_type",{P,S}},
{"get_dither",{P},S},
{"set_dither",{P,S}},
{"get_finishings",{P},S},
{"set_finishings",{P,S}},
{"get_output_bin",{P},S},
{"set_output_bin",{P,S}},
"GtkPrintSettings"}
function newPrintSettings(object x=0, object y=0)
atom err=allocate(8,1)
if atom(x) and x = 0 then
return gtk_func("gtk_print_settings_new")
end if
if class_id(x) = GKeyFile then
y = allocate_string(y,1)
return gtk_func("gtk_print_settings_new_from_key_file",{P,P,P},{x,y,err})
end if
if string(x) and file_exists(canonical_path(x)) then
x = allocate_string(canonical_path(x),1)
return gtk_func("gtk_print_settings_new_from_file",{P,P},{x,err})
end if
end function
function ps_set_page_ranges(atom x, object r)
atom m = allocate_data(8)
poke(m,r[1])
poke(m+4,r[2])
gtk_proc("gtk_print_settings_set_pages_ranges",{P,P,I},{x,m,2})
return 1
end function
widget[GtkPaperSize] = {"gtk_paper_size",
{0},
{"new",{P,P,D,D},-routine_id("newPaperSize")},
{"new_from_ppd",{S,S,D,D},P},
{"new_from_ipp",{S,D,D},P,0,GtkPaperSize}, -- 3.16
{"new_custom",{S,S,D,D,I},P},
{"copy",{P},P,0,GtkPaperSize},
{"is_equal",{P,P},B},
{"get_name",{P},S},
{"get_display_name",{P},S},
{"get_ppd_name",{P},S},
{"get_width",{P,I},D},
{"get_height",{P,I},D},
{"is_custom",{P},B},
{"set_size",{P,D,D,I}},
{"get_default_top_margin",{P,I},D},
{"get_default_bottom_margin",{P,I},D},
{"get_default_left_margin",{P,I},D},
{"get_default_right_margin",{P,I},D},
"GtkPaperSize"}
function newPaperSize(object a=0, object b=0, atom c=0, atom d=0)
if string(a) and atom(b) and b = 0 and c = 0 and d = 0 then
a = allocate_string(a,1)
return gtk_func("gtk_paper_size_new",{P},{a})
end if
if string(a) and atom(b) and b > 0 and c > 0 then
a = allocate_string(a,1)
return gtk_func("gtk_paper_size_new_from_ipp",{P,D,D},{a,b,c})
end if
if string(a) and string(b) and c > 0 and d > 0 then
a = allocate_string(a,1)
b = allocate_string(b,1)
return gtk_func("gtk_paper_size_new_from_ppd",{P,P,D,D},{a,b,c,d})
end if
end function
export function get_paper_sizes(integer cust=0)
object ps = gtk_func("gtk_paper_size_get_paper_sizes",{P},{cust})
ps = unpack_gs_atom_list(ps)
return ps
end function
export function get_paper_size_names(integer cust=0)
object ps = get_paper_sizes(cust)
for i = 1 to length(ps) do
ps[i] = gtk_str_func("gtk_paper_size_get_name",{P},{ps[i]})
end for
return ps
end function
widget[GtkPageSetup] = {"gtk_page_setup",
{GObject},
{"new",{},P},
{"copy",{P},P,0,GtkPageSetup},
{"get_orientation",{P},I},
{"set_orientation",{P,I}},
{"get_paper_size",{P},P,0,GtkPaperSize},
{"set_paper_size",{P,P}},
{"get_top_margin",{P,I},D},
{"set_top_margin",{P,D,I}},
{"get_bottom_margin",{P,I},D},
{"set_bottom_margin",{P,D,I}},
{"get_left_margin",{P,I},D},
{"set_left_margin",{P,D,I}},
{"get_right_margin",{P,I},D},
{"set_right_margin",{P,D,I}},
{"set_paper_size_and_default_margins",{P,P}},
{"get_paper_width",{P,I},D},
{"get_paper_height",{P,I},D},
{"get_page_width",{P,I},D},
{"get_page_height",{P,I},D},
{"new_from_file",{S,P},P,0,GtkPageSetup},
{"load_file",{P,S,P},B},
{"to_file",{P,S},-routine_id("ps_to_file")},
"GtkPageSetup"}
function ps_to_file(atom setup, object filename)
atom err = allocate(8,1) err = 0
return gtk_func("gtk_page_setup_to_file",{P,P,P},{setup,filename,err})
end function
widget[GtkPageRange] = {"gtk_page_range",
{0},
"GtkPageRange"}
widget[GtkPrintOperation] = {"gtk_print_operation",
{GObject},
{"new",{},P},
{"set_allow_async",{P,B}},
{"get_error",{P,P}},
{"set_default_page_setup",{P,P}},
{"get_default_page_setup",{P},P,0,GtkPageSetup},
{"set_print_settings",{P,P}},
{"get_print_settings",{P},P,0,GtkPrintSettings},
{"set_job_name",{P,S}},
{"get_job_name",{P},-routine_id("getPrintOpJobName")},
{"set_n_pages",{P,I}},
{"get_n_pages_to_print",{P},I},
{"set_current_page",{P,I}},
{"set_use_full_page",{P,B}},
{"set_unit",{P,I}},
{"set_export_filename",{P,S}},
{"set_show_progress",{P,B}},
{"set_track_print_status",{P,B}},
{"set_custom_tab_label",{P,S}},
{"run",{P,P,P,P},I},
{"cancel",{P}},
{"draw_page_finish",{P}},
{"set_defer_drawing",{P}},
{"get_status",{P},I},
{"get_status_string",{P},S},
{"is_finished",{P},B},
{"set_support_selection",{P,B}},
{"get_support_selection",{P},B},
{"set_has_selection",{P,B}},
{"get_has_selection",{P},B},
{"set_embed_page_setup",{P,B}},
{"get_embed_page_setup",{P},B},
"GtkPrintOperation"}
function getPrintOpJobName(atom op)
object job = allocate(32,1), err = allocate(32,1) err = 0
gtk_func("g_object_get",{P,P,P,P},{op,"job name",job,err})
object result
ifdef BITS64 then -- thanks pete eberlein
result = peek8u(job)
elsedef
result = peek4u(job)
end ifdef
if result > 0 then
result = peek_string(result)
end if
return result
end function
widget[GtkPrintContext] = {"gtk_print_context",
{GObject},
{"get_cairo_context",{P},P},
{"set_cairo_context",{P,P,D,D}},
{"get_page_setup",{P},P,0,GtkPageSetup},
{"get_width",{P},D},
{"get_height",{P},D},
{"get_dpi_x",{P},D},
{"get_dpi_y",{P},D},
{"get_pango_fontmap",{P},P,0,PangoFontMap},
{"create_pango_context",{P},P,0,PangoContext},
{"create_pango_layout",{P},P,0,PangoLayout},
{"get_hard_margins",{P,D,D,D,D},B},
"GtkPrintContext"}
widget[GtkPrintUnixDialog] = {"gtk_print_unix_dialog",
{GtkDialog,GtkWindow,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{S,P},P},
{"set_page_setup",{P,P}},
{"get_page_setup",{P},P,0,GtkPageSetup},
{"set_current_page",{P,I}},
{"get_current_page",{P},I},
{"set_settings",{P,P}},
{"get_settings",{P},P,0,GtkPrintSettings},
{"get_selected_printer",{P},P,0,GtkPrinter},
{"add_custom_tab",{P,P,P}},
{"set_support_selection",{P,B}},
{"get_support_selection",{P},B},
{"get_has_selection",{P},B},
{"set_embed_page_setup",{P,B}},
{"get_embed_page_setup",{P},B},
{"set_manual_capabilities",{P,I}},
{"get_manual_capabilities",{P},I},
"GtkPrintUnixDialog"}
widget[GtkPageSetupUnixDialog] = {"gtk_page_setup_unix_dialog",
{GtkDialog,GtkWindow,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{S,P},P},
{"set_page_setup",{P,P}},
{"get_page_setup",{P},P,0,GtkPageSetup},
{"set_print_settings",{P,P}},
{"get_print_settings",{P},P,0,GtkPrintSettings},
"GtkPageSetupUnixDialog"}
widget[GtkListBox] = {"gtk_list_box", -- new in GTK 3.10
{GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{},P},
{"prepend",{P,P}},
{"insert",{P,P,I}},
{"select_row",{P,P}},
{"select_all",{P}}, -- 3.14
{"unselect_all",{P}}, -- 3.14
{"unselect_row",{P,P}}, -- 3.14
{"get_selected_row",{P},P,0,GtkListBoxRow},
{"get_selected_rows",{P},X,0,GList},-- 3.14
{"row_is_selected",{P},B}, -- 3.14
{"selected_foreach",{P,P,P}}, -- 3.14
{"set_selection_mode",{P,I}},
{"get_selection_mode",{P},I},
{"set_activate_on_single_click",{P,B}},
{"get_activate_on_single_click",{P},B},
{"set_adjustment",{P,P}},
{"get_adjustment",{P},P,0,GtkAdjustment},
{"set_placeholder",{P,P}},
{"get_row_at_index",{P,I},P,0,GtkListBoxRow},
{"get_row_at_y",{P,I},P,0,GtkListBoxRow},
{"invalidate_filter",{P}},
{"invalidate_headers",{P}},
{"invalidate_sort",{P}},
{"set_filter_func",{P,P,P,P}},
{"set_header_func",{P,P,P,P}},
{"set_sort_func",{P,P,P,P}},
{"drag_highlight_row",{P,P}},
{"drag_unhighlight_row",{P}},
{"bind_model",{P,P,P,P,P}}, -- 3.16
"GtkListBox"}
widget[GtkListBoxRow] = {"gtk_list_box_row",
{GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{},P},
{"changed",{P}},
{"get_header",{P},P,0,GtkWidget},
{"get_type",{},I},
{"set_header",{P,P}},
{"get_index",{P},I},
{"set_activatable",{P,B}},
{"set_selectable",{P,B}},
{"get_selectable",{P},B},
"GtkListBoxRow"}
widget[GtkPopover] = {"gtk_popover", -- new in GTK 3.12
{GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{P,P},-routine_id("newPopover")},
{"bind_model",{P,P,S}},
{"set_relative_to",{P,P}},
{"get_relative_to",{P},P,0,GtkWidget},
{"set_pointing_to",{P,P}},
{"get_pointing_to",{P,P},B},
{"set_position",{P,I}},
{"get_position",{P},I},
{"set_modal",{P,B}},
{"get_modal",{P},B},
{"get_transitions_enabled",{P},B},
{"set_transitions_enabled",{P,B}},
{"get_default_widget",{P},P,0,GtkWidget}, -- 3.18
{"set_default_widget",{P,P}}, -- 3.18
{"get_constrain_to",{P},P}, -- 3.20
{"set_constrain_to",{P,P}}, -- 3.20
{"popup",{P}}, -- 3.21
{"popdown",{P}}, -- 3.21
"GtkPopover"}
function newPopover(atom a=0, atom b=0)
if class_id(b) = GMenuModel then
return gtk_func("gtk_popover_new_from_model",{P,P},{a,b})
else
return gtk_func("gtk_popover_new",{P},{a})
end if
end function
widget[GtkPopoverMenu] = {"gtk_popover_menu", -- 3.16
{GtkPopover,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{},P},
{"open_submenu",{P,S}},
"GtkPopoverMenu"}
widget[GtkPlacesSidebar] = {"gtk_places_sidebar", -- new 3.10
{GtkScrolledWindow,GtkBin,GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{},P},
{"set_open_flags",{P,I}},
{"get_open_flags",{P},I},
{"set_location",{P,P}},
{"get_location",{P},P,0,GFile},
{"set_show_desktop",{P,B}},
{"get_show_desktop",{P},B},
{"add_shortcut",{P,P}},
{"remove_shortcut",{P,P}},
{"list_shortcuts",{P},A,0,GSList},
{"get_nth_bookmark",{P,I},P,0,GFile},
{"get_show_connect_to_server",{P},B}, -- deprecated 3.18
{"set_show_connect_to_server",{P,B}}, -- deprecated 3.18
{"set_local_only",{P,B}}, -- 3.12
{"get_local_only",{P},B}, -- 3.12
{"get_show_enter_location",{P},B}, --3.14
{"set_show_enter_location",{P,B}}, --3.14
{"get_show_other_locations",{P},B}, -- 3.18
{"set_show_other_locations",{P,B}}, -- 3.18
{"get_show_recent",{P},B}, -- 3.18
{"set_show_recent",{P,B}}, -- 3.18
{"get_show_trash",{P},B}, -- 3.18
{"set_show_trash",{P,B}}, -- 3.18
{"set_drop_targets_visible",{P,B,P}}, -- 3.18
"GtkPlacesSidebar"}
widget[GtkHeaderBar] = {"gtk_header_bar", -- new in GTK 3.10
{GtkContainer,GtkWidget,GtkBuildable,GObject},
{"new",{},P},
{"set_title",{P,S}},
{"get_title",{P},S},
{"set_subtitle",{P,S}},
{"get_subtitle",{P},S},
{"set_has_subtitle",{P,B}}, -- 3.12
{"get_has_subtitle",{P},B}, -- 3.12
{"set_custom_title",{P,P}},
{"get_custom_title",{P},P,0,GtkWidget},
{"pack_start",{P,P}},
{"pack_end",{P,P}},
{"set_show_close_button",{P,B}},
{"get_show_close_button",{P},B},
{"set_decoration_layout",{P,S}}, -- 3.12
{"get_decoration_layout",{P},S}, -- 3.12
"GtkHeaderBar"}
widget[GtkPrinter] = {"gtk_printer",
{GObject},
{"new",{S,P,B},P},
{"get_backend",{P},P},
{"get_name",{P},S},
{"get_state_message",{P},S},
{"get_description",{P},S},
{"get_location",{P},S},
{"get_icon_name",{P},S},
{"get_job_count",{P},I},
{"is_active",{P},B},
{"is_paused",{P},B},
{"is_accepting_jobs",{P},B},
{"is_virtual",{P},B},
{"is_default",{P},B},
{"accepts_ps",{P},B},
{"accepts_pdf",{P},B},
--{"list_papers",{P},X,0,GList}, -- buggy!
{"compare",{P,P},I},
{"has_details",{P},B},
{"request_details",{P}},
{"get_capabilities",{P},I},
{"get_default_page_size",{P},P,0,GtkPageSetup},
{"get_hard_margins",{P,D,D,D,D},B},
"GtkPrinter"}
widget[GtkPrintJob] = {"gtk_print_job",
{GObject},
{"new",{S,P,P,P},P},
{"get_settings",{P},P,0,GtkPrintSettings},
{"get_printer",{P},P,0,GtkPrinter},
{"get_title",{P},S},
{"get_status",{P},I},
{"set_source_file",{P,S,P},B},
{"get_surface",{P,P},P,0,CairoSurface_t},
{"send",{P,P,P,P}},
{"set_track_print_status",{P,B}},
{"get_track_print_status",{P},B},
{"get_pages",{P},I},
{"set_pages",{P,I}},
{"get_page_ranges",{P,I},P,0,GtkPageRange},
{"set_page_ranges",{P,P},-routine_id("setPageRanges")},
{"get_page_set",{P},I},
{"set_page_set",{P,I}},
{"get_num_copies",{P},I},
{"set_num_copies",{P,I}},
{"get_scale",{P},D},
{"set_scale",{P,D}},
{"get_n_up",{P},I},
{"set_n_up",{P,I}},
{"get_n_up_layout",{P},I},
{"set_n_up_layout",{P,I}},
{"get_rotate",{P},B},
{"set_rotate",{P,B}},
{"get_collate",{P},B},
{"set_collate",{P,B}},
{"get_reverse",{P},B},
{"set_reverse",{P,B}},
"GtkPrintJob"}
widget[GtkFlowBox] = {"gtk_flow_box", -- GTK 3.12
{GtkContainer,GtkWidget,GtkBuildable,GtkOrientable,GObject},
{"new",{},P},
{"insert",{P,P,I}},
{"get_child_at_index",{P,I},P,0,GtkFlowBoxChild},
{"set_hadjustment",{P,P}},
{"set_vadjustment",{P,P}},
{"set_homogeneous",{P,B}},
{"get_homogeneous",{P},B},
{"set_row_spacing",{P,I}},
{"get_row_spacing",{P},I},
{"set_column_spacing",{P,I}},
{"get_column_spacing",{P},I},
{"set_min_children_per_line",{P,I}},
{"get_min_children_per_line",{P},I},
{"set_max_children_per_line",{P,I}},
{"get_max_children_per_line",{P},I},
{"set_activate_on_single_click",{P,B}},
{"get_activate_on_single_click",{P},B},
{"selected_foreach",{P,P,P}},
{"get_selected_children",{P},X,0,GList},
{"select_child",{P,P}},
{"unselect_child",{P,P}},
{"select_all",{P}},
{"unselect_all",{P}},
{"set_selection_mode",{P,I}},
{"get_selection_mode",{P},I},
{"set_filter_func",{P,P,P,P}},
{"invalidate_filter",{P}},
{"set_sort_func",{P,P,P,P}},
{"invalidate_sort",{P}},
{"bind_model",{P,P,P,P,P}}, -- 3.18
"GtkFlowBox"}
widget[GtkFlowBoxChild] = {"gtk_flow_box_child", -- GTK 3.12
{GtkBin,GtkContainer,GtkWidget,GtkBuildable,GtkOrientable,GObject},
{"new",{},P},
{"get_index",{P},I},
{"is_selected",{P},B},
{"changed",{P}},
"GtkFlowBoxChild"}
widget[GtkMountOperation] = {"gtk_mount_operation",
{GObject},
{"new",{P},P},
{"is_showing",{P},B},
{"set_parent",{P,P}},
{"get_parent",{P},P,0,GtkWindow},
{"set_screen",{P,P}},
{"get_screen",{P},P,0,GdkScreen},
"GtkMountOperation"}
----------------------------------------------------------------------
-- stocklist is not a real GTK widget, we just fake it for convenience
----------------------------------------------------------------------
widget[GtkStockList] = {"gtk_stocklist", -- deprecated in GTK 3.12+
{0},
"GtkStockList"}
function newStockList()
object list = gtk_func("gtk_stock_list_ids")
return to_sequence(list)
end function
----------------------------------------------------------------------
-- Support for Gestures;
----------------------------------------------------------------------
widget[GtkEventController] = {"gtk_event_controller",
{GObject},
{"get_propagation_phase",{P},I},
{"set_propagation_phase",{P,I}},
{"handle_event",{P,P},B},
{"get_widget",{P},P,0,GtkWidget},
{"reset",{P}},
"GtkEventController"}
widget[GdkFrameClock] = {"gdk_frame_clock",
{GObject},
{"get_frame_time",{P},I},
{"request_phase",{P,P}},
{"begin_updating",{P}},
{"end_updating",{P}},
{"get_frame_counter",{P},I},
{"get_history_start",{P},I},
{"get_timings",{P,I},P},
{"get_current_timings",{P},P,0,GdkFrameTimings},
{"get_refresh_info",{P,I,I,I}},
"GdkFrameClock"}
widget[GdkFrameTimings] = {"gdk_frame_timings",
{GObject},
{"get_frame_counter",{P},I},
{"get_complete",{P},B},
{"get_frame_time",{P},I},
{"get_presentation_time",{P},I},
{"get_refresh_interval",{P},I},
{"get_predicted_presentation_time",{P},I},
"GdkFrameTimings"}
widget[GdkEvent] = {"gdk_event",
{GObject},
{"new",{},P},
{"peek",{},P,0,GdkEvent},
{"get",{},P,0,GdkEvent},
{"put",{P}},
{"copy",{P},P,0,GdkEvent},
{"get_axis",{P,I,D},B},
{"get_button",{P,P},B},
{"get_keycode",{P,P},B},
{"get_keyval",{P,P},B},
{"get_root_coords",{P,D,D},B},
{"get_scroll_direction",{P,P},B},
{"get_scroll_deltas",{P,D,D},B},
{"get_state",{P,P},B},
{"get_time",{P},I},
{"get_window",{P},P,0,GdkWindow},
{"get_event_type",{P},I},
{"get_event_sequence",{P},P,0,GdkEventSequence},
{"request_motions",{P}},
{"get_click_count",{P,P},B},
{"get_coords",{P,D,D},B},
{"triggers_context_menu",{P},B},
{"handler_set",{P,P,P}},
{"set_screen",{P,P}},
{"get_screen",{P},P,0,GdkScreen},
{"set_device",{P,P}},
{"get_device",{P},P,0,GdkDevice},
{"set_source_device",{P,P}},
{"get_source_device",{P},P,0,GdkDevice},
"GdkEvent"}
widget[GdkEventSequence] = {"gdk_event_sequence",
{GdkEvent},
"GdkEventSequence"}
widget[GtkGesture] = {"gtk_gesture", --GTK3.14
{GtkEventController,GObject},
{"get_device",{P},P},
{"get_window",{P},P},
{"set_window",{P,P}},
{"is_active",{P},B},
{"is_recognized",{P},B},
{"get_sequence_state",{P,P},I},
{"set_sequence_state",{P,P,I},B},
{"set_state",{P,I},B},
{"get_sequences",{P},A},
{"handles_sequence",{P,P},B},
{"get_last_updated_sequence",{P},P},
{"get_last_event",{P,P},P},
{"get_point",{P,P,D,D},B},
{"get_bounding_box",{P,P},B},
{"get_bounding_box_center",{P,D,D},B},
{"group",{P,P}},
{"ungroup",{P}},
{"get_group",{P},A},
{"is_grouped_with",{P,P},B},
"GtkGesture"}
widget[GtkGestureSingle] = {"gtk_gesture_single",
{GtkGesture,GtkEventController,GObject},
{"get_exclusive",{P},B},
{"set_exclusive",{P,B}},
{"get_touch_only",{P},B},
{"set_touch_only",{P,B}},
{"get_button",{P},I},
{"set_button",{P,I}},
{"get_current_button",{P},I},
{"get_current_sequence",{P},P},
"GtkGestureSingle"}
widget[GtkGestureRotate] = {"gtk_gesture_rotate",
{GtkGesture,GtkEventController,GObject},
{"new",{P},P},
{"get_angle_delta",{P},D},
"GtkGestureRotate"}
widget[GtkGestureZoom] = {"gtk_gesture_zoom",
{GtkGesture,GtkEventController,GObject},
{"new",{P},P},
{"get_scale_delta",{P},D},
"GtkGestureZoom"}
widget[GtkGestureDrag] = {"gtk_gesture_drag", -- 3.14
{GtkGestureSingle,GtkGesture,GtkEventController,GObject},
{"new",{P},P},
{"get_start_point",{P,D,D},B},
{"get_offset",{P,D,D},B},
"GtkGestureDrag"}
widget[GtkGesturePan] = {"gtk_gesture_pan",
{GtkGestureDrag,GtkGestureSingle,GtkGesture,GtkEventController,GObject},
{"new",{P,I},P},
{"get_orientation",{P},I},
{"set_orientation",{P,I}},
"GtkGesturePan"}
widget[GtkGestureSwipe] = {"gtk_gesture_swipe",
{GtkGestureSingle,GtkGesture,GtkEventController,GObject},
{"new",{P},P},
{"get_velocity",{P,D,D},B},
"GtkGestureSwipe"}
widget[GtkGestureLongPress] = {"gtk_gesture_long_press",
{GtkGestureSingle,GtkGesture,GtkEventController,GObject},
{"new",{P},P},
"GtkGestureLongPress"}
widget[GtkGestureMultiPress] = {"gtk_gesture_multi_press",
{GtkGestureSingle,GtkGesture,GtkEventController,GObject},
{"new",{P},P},
{"get_area",{P,P},B},
{"set_area",{P,P}},
"GtkGestureMultiPress"}
widget[GtkPadController] = {"gtk_pad_controller",
{GtkEventController,GObject},
{"new",{P,P,P},P},
{"set_action_entries",{P,P,I}},
{"set_action",{P,I,I,I,S,S}},
"GtkPadController"}
--------------------------------------------------------------------
-- Support for openGL;
--------------------------------------------------------------------
widget[GdkGLProfile] = {"gdk_gl_profile",
{},
"GdkGLProfile"}
widget[GdkGLContext] = {"gdk_gl_context",
{GObject},
{"new",{},-routine_id("newGLContext")},
{"clear_current",{}},
{"make_current",{P}},
{"get_version",{P,I,I}},
{"get_shared_context",{P},P,0,GdkGLContext},
{"get_window",{P},P,0,GdkWindow},
{"get_visual",{P},P,0,GdkVisual},
{"get_display",{P},P,0,GdkDisplay},
{"set_forward_compatible",{P,B}},
{"get_forward_compatible",{P},B},
{"set_debug_enabled",{P,B}},
{"get_debug_enabled",{P},B},
{"set_required_version",{P,I,I}},
{"get_required_version",{P,I,I}},
"GdkGLContext"}
function newGLContext() -- alias for new;
return c_func("gdk_gl_context_get_current")
end function
widget[GtkGLArea] = {"gtk_gl_area", -- GTK 3.16
{GtkWidget,GtkBuildable,GObject},
{"new",{},P},
{"get_context",{P},P},
{"set_has_alpha",{P,B}},
{"get_has_alpha",{P},B},
{"set_has_depth_buffer",{P,B}},
{"get_has_depth_buffer",{P},B},
{"make_current",{P}},
{"get_auto_render",{P},B},
{"set_auto_render",{P,B}},
{"get_error",{P},P},
{"set_error",{P,P}},
{"queue_render",{P}},
{"set_profile",{P,P}},
{"get_profile",{P},P,0,GdkGLProfile},
{"get_has_stencil_buffer",{P},B},
{"set_has_stencil_buffer",{P,B}},
{"attach_buffers",{P}},
{"get_required_version",{P,I,I}},
{"set_required_version",{P,I,I}},
{"get_use_es",{P},B}, -- 3.22
{"set_use_es",{P,B}}, -- 3.22
"GtkGLArea"}
----------------------------------------------------------------
-- low-level x11 functions;
----------------------------------------------------------------
widget[GdkX11Display] = {"gdk_x11_display",
{GObject},
{"get_user_time",{P},I},
{"broadcast_startup_message",{P,S,S,I}},
{"get_startup_notification_id",{P},S},
{"set_startup_notification_id",{P,S}},
{"get_xdisplay",{P},P},
{"grab",{P}},
{"ungrab",{P}},
{"set_cursor_theme",{P,S,I}},
{"set_window_scale",{P,I}},
{"get_glx_version",{P,I,I}},
"GdkX11Display"}
widget[GdkX11Screen] = {"gdk_x11_screen",
{GObject},
{"get_screen_number",{P},I},
{"get_xscreen",{P},P},
{"get_window_manager_name",{P},S},
{"get_monitor_output",{P,I},I},
{"lookup_visual",{P,I},P,0,GdkVisual},
{"get_number_of_desktops",{P},I},
{"get_current_desktop",{P},I},
"GdkX11Screen"}
widget[GdkX11Window] = {"gdk_x11_window",
{GObject},
{"lookup_for_display",{P,P},P,0,GdkWindow},
{"get_xid",{P},P},
{"move_to_current_desktop",{P}},
{"move_to_desktop",{P,I}},
{"get_desktop",{P},I},
"GdkX11Window"}
widget[GtkBindingSet] = {"gtk_binding_set",
{GObject},
{"new",{S},P},
{"by_class",{P},P},
{"find",{S},P},
{"activate",{P,I,I,P},B},
{"add_path",{P,P,S,I}},
"GtkBindingSet"}
widget[GtkBindingEntry] = {"gtk_binding_entry",
{GtkBindingSet},
{"add_signal",{P,I,I,S,P}},
{"add_signal_from_string",{P,S},I},
{"skip",{P,I,I}},
{"remove",{P,I,I}},
"GtkBindingEntry"}
widget[GdkPixbufAnimation] = {"gdk_pixbuf_animation",
{GdkPixbuf,GObject},
{"new",{P},-routine_id("newPixbufAnimation")},
{"get_width",{P},I},
{"get_height",{P},I},
{"get_delay_time",{P},I},
{"is_static_image",{P},B},
{"get_static_image",{P},P,0,GdkPixbuf},
{"get_iter",{P,P},P,0,GdkPixbufAnimationIter},
"GdkPixbufAnimation"}
function newPixbufAnimation(object name)
atom err = allocate(8,1) err = 0
if string(name)
and file_exists(canonical_path(name)) then
name = allocate_string(canonical_path(name),1)
end if
return gtk_func("gdk_pixbuf_animation_new_from_file",{P,P},{name,err})
end function
widget[GdkPixbufAnimationIter] = {"gdk_pixbuf_animation_iter",
{GObject},
{"get_pixbuf",{P},P,0,GdkPixbuf},
{"advance",{P,P},B},
{"get_delay_time",{P},I},
{"on_currently_loading_frame",{P},B},
"GdkPixbufAnimationIter"}
widget[GtkRecentManager] = {"gtk_recent_manager",
{GObject},
{"new",{},-routine_id("recent_manager_get_default")},
{"add_item",{P,S},B},
{"add_full",{P,S,P},B},
{"remove_item",{P,S,P},B},
{"lookup_item",{P,S,P},P,0,GtkRecentInfo},
{"has_item",{P,S},B},
{"move_item",{P,S,S,P},B},
{"get_items",{P},X,0,GtkRecentInfo},
{"purge_items",{P,P},I},
"GtkRecentManager"}
function recent_manager_get_default()
return gtk_func("gtk_recent_manager_get_default")
end function
widget[GtkBuildable] = {"gtk_buildable",
{GObject},
{"set_name",{P,S}},
{"get_name",{P},S},
{"add_child",{P,P,P,S}},
{"set_buildable_property",{P,P,S,P}},
{"construct_child",{P,P,S},P,0,GObject},
{"custom_tag_start",{P,P,P,S,P,P},B},
{"custom_tag_end",{P,P,P,S,P}},
{"custom_finished",{P,P,P,S,P}},
{"parser_finished",{P,P}},
{"get_internal_child",{P,P,S},P,0,GObject},
"GtkBuildable"}
widget[GtkBuilder] = {"gtk_builder",
{GObject},
{"new",{},P},
{"add_callback_symbol",{P,S,P}}, -- 3.10
{"lookup_callback_symbol",{P,S},P}, -- 3.10
{"set_application",{P,P}}, -- 3.10
{"get_application",{P},P,0,GtkApplication}, -- 3.10
{"add_from_file",{P,S},-routine_id("addBuilderObjects")},
{"add_from_string",{P,P},-routine_id("addBuilderObjectsStr")},
{"get_object",{P,P},P},
{"get_objects",{P},A,0,GSList},
{"connect",{P},-routine_id("builder_connect")},
{"set_translation_domain",{P,S}},
{"get_translation_domain",{P},S},
{"get_type_from_name",{P,S},I},
"GtkBuilder"}
export constant builder = create(GtkBuilder)
object current_builder_file = ""
export function ID(atom ctl) -- retrieve the Glade ID property;
return vlookup(ctl,registry,1,4,"!")
end function
export sequence class_name_index = repeat(0,length(widget))
for i = 1 to length(widget) do
if sequence(widget[i]) then
class_name_index[i] = widget[i][$]
end if
end for
constant bad_from_file = define_func("gtk_builder_add_from_file",{P,P,P},I)
constant bad_from_string = define_func("gtk_builder_add_from_string",{P,P,I,P},I)
-- add objects from Glade XML file;
function addBuilderObjects(atom bld, object fname)
atom err = allocate(8,1) err = 0
integer result = c_func(bad_from_file,{bld,fname,err})
if result = 0 then
printf(1,"Error code %d loading Builder\n",err)
if err = 0 then
printf(1,"***** GTK version mismatch or other error in Glade.\n")
printf(1,"\t(remove or change the 'requires...' line)")
Error(,,"Error 8623 loading glade file",peek_string(fname))
end if
abort(0)
end if
return result
end function
-- add object from inline string or string variable;
function addBuilderObjectsStr(atom bld, object str)
current_builder_file = str
atom err = allocate(8,1) err = 0
integer len = length(str)
str = allocate_string(str,1)
integer result = c_func(bad_from_string,{bld,str,len,err})
if result = 0 then
printf(1,"Error 8638: loading Builder %s\n",{current_builder_file})
if err = 0 then
printf(1,"***** GTK version mismatch or other error in Glade.\n")
printf(1,"\t(remove or change the 'requires...' line)")
end if
abort(0)
end if
return result
end function
-- link signals defined in Glade, this starts a 'for' loop,
-- running the builder_connect_function for each control;
function builder_connect(atom bld)
gtk_func("gtk_builder_connect_signals_full",{P,P,P},{bld,builder_connect_func,0})
return 1
end function
constant builder_connect_func = call_back(routine_id("builder_connect_function"))
-- links Glade controls to user-written or Eu functions
-----------------------------------------------------------------------------
function builder_connect_function(atom bld, atom obj, object sig, object hdlr, atom cxo)
-----------------------------------------------------------------------------
hdlr = peek_string(hdlr)
sig = peek_string(sig)
if atom(current_builder_file) and (current_builder_file > 0) then
current_builder_file = peek_string(current_builder_file)
end if
atom rid = routine_id(hdlr)
if rid = -1 then
printf(1,"-----------------------------------------------------------------------\n")
printf(1,"-- Undeclared function in %s\n",{current_builder_file})
printf(1,"-----------------------------------------------------------------------\n")
show_template(hdlr)
abort(1)
else
rid = call_back(rid)
connect(obj,sig,rid,cxo)
end if
return 1
end function
--------------------------------------------------------------------
procedure load_builder(object parent, object child, object prefix=0)
--------------------------------------------------------------------
object name, class, path
object x, tree
integer c,n
atom err = allocate(8,1)
current_builder_file = canonical_path(child)
if file_exists(current_builder_file) then
set(parent,"add from file",current_builder_file,err)
set(parent,"connect")
prefix = filebase(child)
if match(prefix,filebase(prg_name)) then
prefix = 0 -- do not prefix main file objects
end if
x = read_lines(canonical_path(child))
elsif string(child) then
set(parent,"add from string",child,err)
set(parent,"connect")
x = split(child,'\n')
end if
for i = 1 to length(x) do
if string(x[i]) and match("<object class",x[i]) then
c = match("class=",x[i]) + 7
n = match("id=",x[i]) + 4
class = x[i][c..$]
class = split(class," ")
class = class[1]
if class[$] = '"' then class = class[1..$-1] end if
name = x[i][n..$]
n = find('"',name)
name = name[1..n-1]
n = get(builder,"object",name)
if string(prefix) then
name = sprintf("%s:%s",{prefix,name})
end if
ifdef BUILDER then
display("[:25] [:36] [:10>]",{class,name,n})
end ifdef
class = find(class,class_name_index)
if class < 1 then
display("Error finding class for []",{name})
else
if not initialized[class] then
init(class)
end if
tree = widget[class][2]
for z = 1 to length(tree) do
init(tree[z])
end for
register(n,class,name)
end if
end if
end for
end procedure
-------------------------------------------------------------------------------
procedure show_template(object handlr) -- prompt for missing functions w/Glade;
-------------------------------------------------------------------------------
printf(1,"""
________
-----------------------------------------------------------------------
global function %s()
-----------------------------------------------------------------------
return 1
end function
""",{handlr})
end procedure
------------------------------------------------------------------------
-- Internet conveniences
------------------------------------------------------------------------
------------------------------------
export function show_uri(object uri)
------------------------------------
if atom(uri) then
return 0
end if
display("URI: []\n",{uri})
integer x = find('#',uri) -- in case link to html section;
object tmp
if x > 0 then
tmp = canonical_path(uri[1..x-1])
if file_exists(tmp) then
uri = tmp & uri[x..$]
end if
else
tmp = canonical_path(uri)
if file_exists(tmp) then
uri = tmp
end if
end if
ifdef WINDOWS then
system("explore " & uri,0)
return 1
end ifdef
atom err = allocate(8,1) err=0
object result = gtk_func("gtk_show_uri",{P,P,P,P},
{0,allocate_string(uri,1),0,err})
return result
end function
---------------------------------------------------------------------------
-- Icon functions
----------------------------
export function list_icons()
----------------------------
atom theme = gtk_func("gtk_icon_theme_get_default")
object list = gtk_func("gtk_icon_theme_list_icons",{P,P},{theme,0})
return to_sequence(list)
end function
----------------------------------------
export function has_icon(object name)
----------------------------------------
atom theme = gtk_func("gtk_icon_theme_get_default")
name = allocate_string(name,1)
return gtk_func("gtk_icon_theme_has_icon",{P,P},{theme,name})
end function
----------------------------------------------------------------
export function valid_icon(object list)
----------------------------------------------------------------
-- check a list of possible icon names
object result = 0
if atom(list[1]) then
list = {list}
end if
for i = 1 to length(list) do
result = get_icon_image(list[i]) --display(result)
if string(result) then return 1 end if
end for
return result
end function
---------------------------------------------------------------
export function valid_icon_name(object list)
---------------------------------------------------------------
-- check a list of possible icon names,
-- return string name of first valid
for i = 1 to length(list) do
if valid_icon({list[i]}) > 0 then
return list[i]
end if
if file_exists(locate_file(list[i])) then
return list[i]
end if
end for
return "gtk-missing-image"
end function
-- get image from a variety of sources;
------------------------------------------------------------------------------------
function get_icon_image(object icon, object sizex=0, object sizey=0, object sizez=1)
-------------------------------------------------------------------------------------
atom img = 0, ani = 0, default_theme, handle
handle = to_number(icon)
if class_id(handle) = GdkPixbuf then
img = create(GtkImage,handle)
return img
end if
if class_id(handle) = GtkImage then
return handle
end if
if find(icon,stock_list) then
img = gtk_func("gtk_image_new_from_stock",{P,I},
{allocate_string(icon,1),sizex})
return img
end if
default_theme = gtk_func("gtk_icon_theme_get_default",{})
if gtk_func("gtk_icon_theme_has_icon",{P,P},
{default_theme,allocate_string(icon,1)}) then
img = create(GdkPixbuf,icon,18,18,sizez)
img = create(GtkImage,img)
register(img,GtkImage)
--display("Has icon []",{icon})
return img
end if
icon = locate_file(icon)
if file_type(icon) = 1 then -- image from file
ani = create(GdkPixbufAnimation,icon,sizex,sizey)
if gtk_func("gdk_pixbuf_animation_is_static_image",{P},{ani}) then
ani = create(GdkPixbuf,icon,sizex*6,sizey*6,sizez)
img = create(GtkImage,ani)
else
img = create(GtkImage)
set(img,"from animation",ani)
end if
return img
end if
return 0
end function
--------------------------------------------------------
export function icon_info(object name, integer size=6)
--------------------------------------------------------
atom theme = gtk_func("gtk_icon_theme_get_default")
atom err = allocate(8,1) err = 0
atom icon_info = gtk_func("gtk_icon_theme_lookup_icon",{P,P,I,I},
{theme,name,size,GTK_ICON_LOOKUP_USE_BUILTIN})
object results = repeat(0,5)
results = {
gtk_func("gtk_icon_info_load_icon",{P,P},{icon_info,err}),
gtk_func("gtk_icon_info_get_display_name",{P},{icon_info}),
gtk_str_func("gtk_icon_info_get_filename",{P},{icon_info}),
gtk_func("gtk_icon_info_get_base_size",{P},{icon_info}),
gtk_func("gtk_icon_info_get_base_scale",{P},{icon_info})
}
return results
-- returns {1,2,3,4,5}
-- 1 = pointer to icon_info structure,
-- 2 = display name or null,
-- 3 = full path to icon file,
-- 4 = base size,
-- 5 = base scale
-- some entries missing in some cases
end function
-----------------------------------------------------------------------------------------
export function xpm_to_pixbuf(object xpm, integer w=0, integer h=0, integer interp=2)
-----------------------------------------------------------------------------------------
atom x = gtk_func("gdk_pixbuf_new_from_xpm_data",{P},
{allocate_string_pointer_array(xpm)})
if w + h > 0 then
x = gtk_func("gdk_pixbuf_scale_simple",{P,I,I,I},{x,w,h,interp})
end if
register(x,GdkPixbuf)
return x
end function
------------------------------------------------------------------------
-- Following 3 functions simplify method calls; used mostly internally,
-- but can also be called by the programmer to execute any GTK, GDK or
-- GLib function which has not been implemented in EuGTK.
-------------------------------------------------------------------------
export function gtk_func(object name, object params={}, object values={})
-------------------------------------------------------------------------
-- syntax: result = gtk_func("gtk_*_*",{formal params},{values})
-- where formal params might be {P,P,I} (function expects Ptr, Ptr, and Int)
-- and values are the values to be inserted into the formal params before
-- the function is called;
name = '+' & name
for i = 1 to length(params) do
if string(values[i]) then
values[i] = allocate_string(values[i],1)
end if
end for
if atom(values) then
values = {values}
end if
atom fn = define_func(name,params,P)
if fn > 0 then
return c_func(fn,values)
else
return -1
end if
end function
-----------------------------------------------------------------------------
export function gtk_str_func(object name, object params={}, object values={})
-----------------------------------------------------------------------------
-- syntax: same as above, except a string result is returned
for i = 1 to length(params) do
if string(values[i]) then
values[i] = allocate_string(values[i],1)
end if
end for
name = '+' & name
atom fn = define_func(name,params,P)
object result
if fn > 0 then
if length(params) > 0 then
result = c_func(fn,values)
else
result = c_func(fn,{})
end if
if result > 0 then
return peek_string(result)
end if
end if
return 0
end function
--------------------------------------------------------------------------
export function gtk_proc(object name, object params={}, object values={})
--------------------------------------------------------------------------
-- syntax: same as above, but no value is returned, used to call GTK procs
atom fn
if string(values) then values = {values} end if
name = '+' & name
for i = 1 to length(params) do
if sequence(values) and string(values[i]) then
values[i] = allocate_string(values[i]) -- keep
end if
end for
if length(params) = 0 then
fn = define_proc(name)
if fn > 0 then
c_proc(fn,{})
end if
else
fn = define_proc(name,params)
if fn > 0 then
if atom(values) then values = {values} end if
c_proc(fn,values)
end if
end if
return values
end function
-- The following 2 functions had to be added for Windows, so that we could search
-- a list of dlls until we find the function name requested. I'm not sure the '+'
-- is necessary for 32-bit Windows, since I don't have a 32-bit computer anymore.
----------------------------------------------------------------------------------------
export function define_proc(object name, object params={})
----------------------------------------------------------------------------------------
atom x
for i = 1 to length(LIBS) do
if atom(LIBS[i]) and LIBS[i] > 0 then
x = define_c_proc(LIBS[i],name,params)
if x > 0 then
return x
end if
end if
end for
return -1
end function
---------------------------------------------------------------------------
export function define_func(object name, object params={}, object values=P)
---------------------------------------------------------------------------
atom x
ifdef BITS32 and WINDOWS then name = '+' & name end ifdef
for i = 1 to length(LIBS) do
if atom(LIBS[i]) and LIBS[i] > 0 then
x = define_c_func(LIBS[i],name,params,values)
if x > 0 then
return x
end if
end if
end for
return -1
end function
-----------------------------------------------------------------------------------
-- Color handling routines - most are used internally, but exported if you need 'em
-----------------------------------------------------------------------------------
----------------------------------------
export function to_rgba(object color) -- converts a color description to rgba ptr;
----------------------------------------
atom rgba = allocate(32) -- keep;
object c = color
if string(c) then c = allocate_string(c,1) end if
if gtk_func("gdk_rgba_parse",{P,P},{rgba,c}) then
return rgba
else
printf(1,"\nError: invalid color '%s'\n******\n",{color})
return 0
end if
return rgba
end function
-------------------------------------------------------
export function from_rgba(object rgba, object fmt=0) -- converts rgba ptr to description;
-------------------------------------------------------
object result = gtk_str_func("gdk_rgba_to_string",{P},{rgba})
if fmt=0 then return result
else return fmt_color(result,fmt)
end if
end function
----------------------------------------------
function fmt_color(object s, integer fmt=0) -- Convert color to various formats;
----------------------------------------------
if atom(s) then
if string(peek_string(s)) then
s = peek_string(s)
end if
end if
object w
w = split_any(s,"(,)")
if length(w[1]) = 3 then
w[5] = "1"
end if
for i = 2 to 5 do
w[i] = to_number(w[i])
end for
if atom(w[5]) then
w[5] = round(w[5],100)
end if
switch fmt do
case 0 then return w[1..length(w[1])+1]
case 1 then return sprintf("#%02x%02x%02x",w[2..4])
case 2 then return (256*256*w[2])+(256*w[3])+ w[4]
case 3 then return {w[2],w[3],w[4]}
case 4 then return {w[2],w[3],w[4],w[5]}
case 5 then return {w[2],w[3],w[4],256*w[5]}
case 6 then return sprintf("rgba(%d,%d,%d,%2.2f)",w[2..$])
case 7 then return {w[2]/255,w[3]/255,w[4]/255,w[5]}
case 8 then return sprintf("r=#%x, g=#%x, b=#%x, alpha=#%x",w[2..5])
case else -- do nothing
end switch
return s
end function
------------------------------------------------------------------------
-- Following are 5 pre-built, easy to use popup dialogs
-- which save you the trouble of writing tons of code!
-- Refer to documentation/dialogs.html for details.
-- Rewritten for 4.8.8 to preserve images on dialog buttons despite
-- GTK developers' bland, boring preferences :P
-- Beginning with EuGTK 4.9.3, dialogs can be non-modal if desired.
------------------------------------------------------------------------
public function Info(object parent=0, object title="Info",
object pri_txt="", object sec_txt="",
object btns=GTK_BUTTONS_OK,
object image="dialog-information",
object icon=0,
integer modal=1,
object addon=0,
integer x=-1,
integer y=-1,
object name="Info")
return Custom(parent,title,pri_txt,sec_txt,btns,image,icon,modal,addon,x,y,name)
end function
public function Warn(object parent=0, object title="Warning",
object pri_txt="", object sec_txt="",
object btns=GTK_BUTTONS_CLOSE,
object image="dialog-warning",
object icon=0,
integer modal=1,
object addon=0,
integer x=-1,
integer y=-1,
object name="Warn")
return Custom(parent,title,pri_txt,sec_txt,btns,image,icon,modal,addon,x,y,name)
end function
public function Error(object parent=0, object title="Error",
object pri_txt="", object sec_txt="",
object btns=GTK_BUTTONS_OK_CANCEL,
object image="dialog-error",
object icon=0,
integer modal=1,
object addon=0,
integer x=-1,
integer y=-1,
object name="Error")
return Custom(parent,title,pri_txt,sec_txt,btns,image,icon,modal,addon,x,y,name)
end function
public function Question(object parent=0, object title="Question",
object pri_txt="", object sec_txt="",
object btns=GTK_BUTTONS_YES_NO,
object image="dialog-question",
object icon=0,
integer modal=1,
object addon=0,
integer x=-1,
integer y=-1,
object name="Question")
return Custom(parent,title,pri_txt,sec_txt,btns,image,icon,modal,addon,x,y,name)
end function
integer closedlg = call_back(routine_id("close_dialog"))
--------------------------------------------------------------
public function Custom(
object parent=0, --1
object title="Dialog", --2
object pri_txt="", --3
object sec_txt="", --4
object btns=GTK_BUTTONS_OK, --5
object image=0, --6
object icon=0, --7
integer modal=GTK_DIALOG_MODAL, --8
object addon=0, --9
integer x=-1, --10
integer y=-1, --11
object name="Custom") --12
--------------------------------------------------------------
atom dlg = create(GtkDialog)
atom btnbox = create(GtkButtonBox)
atom ca = 0
atom top = 0, left = 0, right = 0
atom lbl1 = 0
atom capanel = create(GtkBox,VERTICAL)
object btn = repeat(0,2)
if string(parent) then
parent = get(builder,"object",parent)
end if
if parent = 0 then
for i = 1 to length(registry) do
if registry[i][2] = 293 then
parent = registry[i][1]
exit
end if
end for
end if
if parent > 0 and atom(icon) and icon = 0 then
icon = get(parent,"icon name")
end if
if atom(pri_txt) and pri_txt > 0 then pri_txt = unpack(pri_txt) end if
if atom(sec_txt) and sec_txt > 0 then sec_txt = unpack(sec_txt) end if
if class_id(addon) = GdkPixbuf then addon = create(GtkImage,addon) end if
set(dlg,{
{"transient for",parent},
{"title"," " & title},
{"border width",5},
{"icon",icon},
{"position",GTK_WIN_POS_MOUSE}})
if string(name) then
set(dlg,"name",name)
end if
ca = get(dlg,"content area")
capanel = create(GtkBox,VERTICAL)
add(ca,capanel)
top = create(GtkBox,HORIZONTAL,2)
add(capanel,top)
left = create(GtkBox,VERTICAL,5)
right = create(GtkBox,VERTICAL,5)
add(top,{left,right})
if string(image) then
add(left,create(GtkImage,image,GTK_ICON_SIZE_DIALOG))
elsif image > 0 then
if class_id(image) = GdkPixbuf
or class_id(image) = GIcon then
image = create(GtkImage,image)
end if
add(left,image)
end if
lbl1 = create(GtkLabel)
set(lbl1,"name",name & "_label")
set(lbl1,"markup",text:format("<b>[]</b>\n[]",{pri_txt,sec_txt}))
set(lbl1,"halign",0)
add(right,lbl1)
if atom(addon) and addon > 0 then
atom p2 = create(GtkBox,VERTICAL)
add(capanel,p2)
if get(addon,"parent") != 0 then
set(addon,"reparent",p2)
else
add(p2,addon)
end if
end if
show_all(capanel)
if integer(btns) then
switch btns do
case GTK_BUTTONS_NONE then break
case GTK_BUTTONS_OK then
btn[1] = create(GtkButton,"gtk-ok")
set(dlg,"add action widget",btn[1],MB_OK)
show(btn[1])
case GTK_BUTTONS_OK_CANCEL then
btn[1] = create(GtkButton,"gtk-cancel")
btn[2] = create(GtkButton,"gtk-ok")
set(dlg,"add action widget",btn[1],MB_CANCEL)
set(dlg,"add action widget",btn[2],MB_OK)
show(btn[1]) show(btn[2])
case GTK_BUTTONS_CLOSE then
btn[1] = create(GtkButton,"gtk-close")
set(btn[1],"can default",TRUE)
set(dlg,"add action widget",btn[1],MB_CLOSE)
show(btn[1])
case GTK_BUTTONS_YES_NO then
btn[1] = create(GtkButton,"gtk-yes")
set(dlg,"add action widget",btn[1],MB_YES)
btn[2] = create(GtkButton,"gtk-no")
set(dlg,"add action widget",btn[2],MB_NO)
show(btn[1]) show(btn[2])
case else btn[1] = create(GtkButton,"gtk-ok")
set(btn[1],"can default",TRUE)
set(dlg,"add action widget",btn[1],MB_OK)
show(btn[1])
end switch
end if
if sequence(btns) and not atom(btns[1]) then
set(btnbox,"margin top",5)
pack(capanel,-btnbox)
for i = 1 to length(btns) do
while length(btns[i]) < 3 do btns[i] &= 0 end while
if atom(btns[i][2]) and btns[i][2] = 0 then btns[i][2] = closedlg end if
if atom(btns[i][3]) and btns[i][3] = 0 then btns[i][3] = {dlg,MB_CANCEL} end if
btns[i] = create(GtkButton,btns[i][1],btns[i][2],btns[i][3])
end for
add(btnbox,btns)
show_all(btnbox)
end if
if x+y > 0 then
set(dlg,"move",x,y)
end if
atom result = 0
set(dlg,"modal",modal)
if modal = GTK_DIALOG_NON_MODAL then
return show_all(dlg)
else
result = get(dlg,"run")
destroy(dlg)
end if
return result
end function
-------------------------------
export function run(object dlg)
-------------------------------
if string(dlg) then
dlg = pointer(dlg)
end if
object result = get(dlg,"run")
return result
end function
global integer dialog_return_value = 0
function close_dialog(object ctl, object dlg)
dlg = unpack(dlg)
dialog_return_value = dlg[2]
set(dlg[1],"hide")
return 1
end function
--------------------------------------------
-- Nifty shortcut, thanks to Greg Haberek,
-- allows using local functions without
-- call_back(routine_id()) and scope issues:
--------------------------------------------
export function _(sequence name, atom rid = routine_id(name))
if rid > 0 then
return call_back(rid)
end if
return 0
end function
---------------------------------
-- © 2016 by Irv Mullins
---------------------------------
Reference in New Issue View Git Blame Copy Permalink