diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..02c43ee --- /dev/null +++ b/Makefile @@ -0,0 +1,49 @@ +# Makefile +# vala project +# + +# name of your project/program +PROGRAM = neo_layout_viewer +BINDIR = bin + +# for most cases the following two are the only you'll need to change +# add your source files here +SRC = neo2.vala key-overlay.vala tray.vala config-manager.vala keybinding-manager.vala + +# add your used packges here +PKGS = --pkg x11 --pkg keysym --pkg gtk+-2.0 --pkg gee-1.0 --pkg gdk-x11-2.0 --pkg posix +#PKGS = --pkg keysym --pkg x11 --pkg gtk+-2.0 --pkg gee-1.0 --pkg gdk-x11-2.0 --pkg posix + +CC_INCLUDES = +# vala compiler +VALAC = valac +#VAPIDIR = --vapidir=vapi/ +VAPIDIR = --vapi=vapi/keysym.vapi + +# compiler options for a debug build +VALACOPTS = -g --save-temps + +# set this as root makefile for Valencia +BUILD_ROOT = 1 + + +# the 'all' target build a debug build +all: $(BINDIR) bulid_debug + +# the 'release' target builds a release build +# you might want to disabled asserts also +release: $(BINDIR) clean bulid_release + +$(BINDIR): + mkdir -p $(BINDIR) + ln -s ../assets bin/assets + +bulid_debug: + @$(VALAC) $(VAPIDIR) $(VALACOPTS) $(SRC) -o $(BINDIR)/$(PROGRAM) $(PKGS) $(CC_INCLUDES) + +bulid_release: + @$(VALAC) -X -O2 $(VAPIDIR) $(SRC) -o $(BINDIR)/$(PROGRAM)_release $(PKGS) $(CC_INCLUDES) + +# clean all built files +clean: + @rm -v -fr *~ *.c $(PROGRAM) diff --git a/README b/README index e69de29..da0d70f 100644 --- a/README +++ b/README @@ -0,0 +1,9 @@ + + + +Errors: + +Not all keysyms found. make returns i.e. +[..]/key-overlay.c:1744: error: ‘XK_logicalor’ undeclared (first use in this function) + +Solution: define all groups in /etc/include/X11/keysym.def. I.e. add “#define XK_TECHNICAL“. diff --git a/assets/icons/Neo-Icon.png b/assets/icons/Neo-Icon.png new file mode 100644 index 0000000..62bc420 Binary files /dev/null and b/assets/icons/Neo-Icon.png differ diff --git a/assets/neo2.1/tastatur_neo_Ebene1.png b/assets/neo2.1/tastatur_neo_Ebene1.png new file mode 100644 index 0000000..9009d03 Binary files /dev/null and b/assets/neo2.1/tastatur_neo_Ebene1.png differ diff --git a/assets/neo2.1/tastatur_neo_Ebene2.png b/assets/neo2.1/tastatur_neo_Ebene2.png new file mode 100644 index 0000000..8363937 Binary files /dev/null and b/assets/neo2.1/tastatur_neo_Ebene2.png differ diff --git a/assets/neo2.1/tastatur_neo_Ebene3.png b/assets/neo2.1/tastatur_neo_Ebene3.png new file mode 100644 index 0000000..41fda9f Binary files /dev/null and b/assets/neo2.1/tastatur_neo_Ebene3.png differ diff --git a/assets/neo2.1/tastatur_neo_Ebene4.png b/assets/neo2.1/tastatur_neo_Ebene4.png new file mode 100644 index 0000000..44e99fc Binary files /dev/null and b/assets/neo2.1/tastatur_neo_Ebene4.png differ diff --git a/assets/neo2.1/tastatur_neo_Ebene5.png b/assets/neo2.1/tastatur_neo_Ebene5.png new file mode 100644 index 0000000..c4cd005 Binary files /dev/null and b/assets/neo2.1/tastatur_neo_Ebene5.png differ diff --git a/assets/neo2.1/tastatur_neo_Ebene6.png b/assets/neo2.1/tastatur_neo_Ebene6.png new file mode 100644 index 0000000..becdbec Binary files /dev/null and b/assets/neo2.1/tastatur_neo_Ebene6.png differ diff --git a/config-manager.vala b/config-manager.vala new file mode 100644 index 0000000..44f1931 --- /dev/null +++ b/config-manager.vala @@ -0,0 +1,129 @@ + +namespace NeoLayoutViewer{ + class ConfigManager { + + //public Gee.HashMap config = new Gee.HashMax(); + //public Gee.HashMap config { get; set; default = new Gee.HashMap();}; + public Gee.HashMap config;// { get; set; }; + + public ConfigManager(string conffile) { + this.config = new Gee.HashMap(); + + //add defaults values, if key not set in the config file + add_defaults(); + + if(!search_config_file(conffile)) + create_conf_file(conffile); + + if(search_config_file(conffile)) + load_config_file(conffile); + + + add_intern_values(); + } + + public Gee.HashMap getConfig(){ + return config; + } + + /* + Standardwerte der Einstellungen. Sie werden in eine Konfigurationsdatei geschrieben, falls + diese Datei nicht vorhanden ist. + */ + public void add_defaults(){ + config.set("show_shortcut","N"); + config.set("on_top","1"); + config.set("position","5"); + config.set("width","1000");//Skalierung, sofern wert zwischen width(resolution)*max_width und width(resolution)*min_width + config.set("min_width","0.25");//Relativ zur Auflösung + config.set("max_width","0.5");//Relativ zur Auflösung + config.set("move_shortcut","R"); + //config.set("position_cycle","3 3 9 1 3 9 1 7 7"); + config.set("position_cycle","2 3 6 1 3 9 4 7 8"); + config.set("display_numblock","1"); + } + + /* + Einstellungen, die der Übersicht halber nicht in der Konfigurationsdatei stehen. + */ + private void add_intern_values(){ + config.set("numblock_width","350"); + + } + + private bool search_config_file(string conffile){ + var file = File.new_for_path (conffile); + return file.query_exists(null); + } + + private int create_conf_file(string conffile){ + var file = File.new_for_path (conffile); + + + try{ + //Create a new file with this name + var file_stream = file.create (FileCreateFlags.NONE); + // Test for the existence of file + if (! file.query_exists ()) { + stdout.printf ("Can't create config file.\n"); + return -1; + } + // Write text data to file + var data_stream = new DataOutputStream (file_stream); + /* + data_stream.put_string ("#Show/Hide the window\n"); + data_stream.put_string ("show_shortcut=R\n"); + data_stream.put_string ("#Show window on top\n"); + data_stream.put_string ("on_top=1\n"); + */ + foreach( Gee.Map.Entry e in this.config.entries){ + data_stream.put_string ( e.key+" = "+e.value+"\n" ); + } + } // Streams + catch ( GLib.IOError e){ return -1; } + catch ( GLib.Error e){ return -1; } + + return 0; + } + + private int load_config_file(string conffile){ + + // A reference to our file + var file = File.new_for_path (conffile); + + try { + // Open file for reading and wrap returned FileInputStream into a + // DataInputStream, so we can read line by line + var in_stream = new DataInputStream (file.read (null)); + string line; + string[] split; + var comment = new Regex("^#.*$"); + var regex = new Regex("(#[^=]*)*[ ]*=[ ]*"); + + // Read lines until end of file (null) is reached + while ((line = in_stream.read_line (null, null)) != null) { + //stdout.printf ("%s\n", line); + if( comment.match(line)) continue; + split = regex.split(line); + if(split.length>1){ + //debug(split[0]+" "+split[1]+"\n"); + this.config.set(split[0],split[1]); + } + } + } catch (GLib.IOError e) { + error ("%s", e.message); + //return -1; + } catch (RegexError e) { + error ("%s", e.message); + //return -1; + }catch (GLib.Error e) { + error ("%s", e.message); + //return -1; + } + + return 0; + } + + + } + } diff --git a/key-overlay.vala b/key-overlay.vala new file mode 100644 index 0000000..5c04643 --- /dev/null +++ b/key-overlay.vala @@ -0,0 +1,609 @@ +/* + Known Problems: + - Tab, Shift+Tab, Shift+Space, Numblock not implemented + - Some special characters, i.e ℂ, not implemented, because the unicode numbers + not defined in keysymdef.h (and left in the vapi file, too). +*/ +using Gtk; +using Gdk; +using X; +//using Keysym;//keysymdef.h +using Posix;//system-call + + +namespace NeoLayoutViewer{ + + private class ArrayBox { + public uint[] val; + public ArrayBox(uint[] val){ + this.val = val; + } + } + + public class KeyOverlay : VBox { + + public Gee.HashMap keyBoxes; + public Gee.HashMap keysyms; + private NeoWindow winMain; + + public KeyOverlay(NeoWindow winMain) { + //base(true,0); + this.set_homogeneous(false); + this.set_spacing(0); + this.winMain = winMain; + this.keysyms = generateKeysyms(); + + this.keyBoxes = new Gee.HashMap(); + generateKeyevents(); + } + + public Gee.HashMap generateKeysyms(){ + keysyms = new Gee.HashMap(); + + keysyms.set(8, new ArrayBox({})); + keysyms.set(9, new ArrayBox({XK_Escape, 0, XK_Escape})); + keysyms.set(10, new ArrayBox({XK_1, XK_degree, XK_onesuperior, XK_onesubscript, XK_ordfeminine, 0, XK_notsign})); + keysyms.set(11, new ArrayBox({XK_2, XK_section, XK_twosuperior, XK_twosubscript, XK_masculine, 0, XK_logicalor})); + keysyms.set(12, new ArrayBox({XK_3, 0, XK_threesuperior, XK_threesubscript, XK_numerosign, 0, XK_logicaland})); + keysyms.set(13, new ArrayBox({XK_4, XK_guillemotright, 0, 0, XK_Prior, XK_Prior, 0})); + keysyms.set(14, new ArrayBox({XK_5, XK_guillemotleft, 0, 0, XK_periodcentered, 0, 0})); + keysyms.set(15, new ArrayBox({XK_6, XK_EuroSign, XK_cent, 0, XK_sterling, 0, 0})); + keysyms.set(16, new ArrayBox({XK_7, XK_dollar, XK_yen, XK_Greek_kappa, XK_currency, 0, XK_rightarrow})); + keysyms.set(17, new ArrayBox({XK_8, 0, 0, 0, 0, 0, 0})); + keysyms.set(18, new ArrayBox({XK_9, 0, 0, 0, XK_slash, 0, XK_containsas})); + keysyms.set(19, new ArrayBox({XK_0, 0, XK_zerosubscript, XK_asterisk, 0, XK_emptyset})); + keysyms.set(20, new ArrayBox({XK_minus, 0, 0, 0, XK_minus, 0, XK_hyphen})); + keysyms.set(21, new ArrayBox({XK_dead_grave, 0, XK_dead_diaeresis, XK_dead_abovereversedcomma})); + keysyms.set(22, new ArrayBox({XK_BackSpace, XK_BackSpace, XK_BackSpace, XK_BackSpace, XK_BackSpace, XK_BackSpace, XK_BackSpace})); + keysyms.set(23, new ArrayBox({XK_Tab, XK_ISO_Left_Tab, XK_Multi_key})); + keysyms.set(24, new ArrayBox({XK_x, XK_X, 0, XK_Greek_xi, 0, 0, XK_Greek_XI})); + keysyms.set(25, new ArrayBox({XK_v, XK_V, XK_underscore, 0, XK_BackSpace, XK_BackSpace, 0})); + keysyms.set(26, new ArrayBox({XK_l, XK_L, XK_bracketleft, XK_Greek_lamda, XK_Up, XK_Up, XK_Greek_LAMDA})); + keysyms.set(27, new ArrayBox({XK_c, XK_C, XK_bracketright, XK_Greek_chi, XK_Delete, XK_Delete, 0})); + keysyms.set(28, new ArrayBox({XK_w, XK_W, XK_asciicircum, XK_Greek_omega, XK_Insert, XK_Insert, XK_Greek_OMEGA})); + keysyms.set(29, new ArrayBox({XK_k, XK_K, XK_exclam, 0, XK_exclamdown, 0, XK_radical})); + keysyms.set(30, new ArrayBox({XK_h, XK_H, XK_less, XK_Greek_psi, XK_7, 0, XK_Greek_PSI})); + keysyms.set(31, new ArrayBox({XK_g, XK_G, XK_greater, XK_Greek_gamma, XK_8, 0, XK_Greek_GAMMA})); + keysyms.set(32, new ArrayBox({XK_f, XK_F, XK_equal, XK_Greek_phi, XK_9, 0, XK_Greek_PHI})); + keysyms.set(33, new ArrayBox({XK_q, XK_Q, XK_ampersand, 0, XK_plus, 0, 0})); + keysyms.set(34, new ArrayBox({XK_ssharp, 0, 0, XK_Greek_finalsmallsigma, 0, 0, 0})); + keysyms.set(35, new ArrayBox({XK_dead_acute, XK_dead_cedilla, XK_dead_stroke, XK_dead_abovecomma, XK_dead_doubleacute, 0, XK_dead_abovedot})); + keysyms.set(36, new ArrayBox({XK_Return, 0, XK_Return})); + keysyms.set(37, new ArrayBox({XK_Control_L, 0, XK_Control_L})); + keysyms.set(38, new ArrayBox({XK_u, XK_U, XK_backslash, 0, XK_Home, XK_Home, 0})); + keysyms.set(39, new ArrayBox({XK_i, XK_I, XK_slash, XK_Greek_iota, XK_Left, XK_Left, XK_integral})); + keysyms.set(40, new ArrayBox({XK_a, XK_A, XK_braceleft, XK_Greek_alpha, XK_Down, XK_Down, 0})); + keysyms.set(41, new ArrayBox({XK_e, XK_E, XK_braceright, XK_Greek_epsilon, XK_Right, XK_Right, 0})); + keysyms.set(42, new ArrayBox({XK_o, XK_O, XK_asterisk, XK_Greek_omicron, XK_End, XK_End, XK_elementof})); + keysyms.set(43, new ArrayBox({XK_s, XK_S, XK_question, XK_Greek_sigma, XK_questiondown, 0, XK_Greek_SIGMA})); + keysyms.set(44, new ArrayBox({XK_n, XK_N, XK_parenleft, XK_Greek_nu, XK_4, 0, 0})); + keysyms.set(45, new ArrayBox({XK_r, XK_R, XK_parenright, 0, XK_5, 0, 0})); + keysyms.set(46, new ArrayBox({XK_t, XK_T, XK_minus, XK_Greek_tau, XK_6, 0, XK_partialderivative})); + keysyms.set(47, new ArrayBox({XK_d, XK_D, XK_colon, XK_Greek_delta, XK_comma, 0, XK_Greek_DELTA})); + keysyms.set(48, new ArrayBox({XK_y, XK_Y, XK_at, XK_Greek_upsilon, XK_period, 0, XK_nabla})); + keysyms.set(49, new ArrayBox({XK_dead_circumflex, XK_dead_tilde, XK_dead_abovering, XK_dead_breve, XK_dead_caron, 0, XK_dead_macron})); + keysyms.set(50, new ArrayBox({XK_Shift_L, 0, XK_Shift_L})); + keysyms.set(51, new ArrayBox({XK_ISO_Level3_Shift, XK_ISO_Level3_Shift, XK_Caps_Lock, XK_Caps_Lock})); + keysyms.set(52, new ArrayBox({XK_udiaeresis, XK_Udiaeresis, XK_numbersign, 0, XK_Escape, XK_Escape, 0})); + keysyms.set(53, new ArrayBox({XK_odiaeresis, XK_Odiaeresis, XK_dollar, 0, XK_Tab, XK_Tab, 0})); + keysyms.set(54, new ArrayBox({XK_adiaeresis, XK_Adiaeresis, XK_bar, XK_Greek_eta, XK_Next, XK_Next, 0})); + keysyms.set(55, new ArrayBox({XK_p, XK_P, XK_asciitilde, XK_Greek_pi, XK_Return, XK_Return, XK_Greek_PI})); + keysyms.set(56, new ArrayBox({XK_z, XK_Z, XK_grave, XK_Greek_zeta, 0, 0, 0})); + keysyms.set(57, new ArrayBox({XK_b, XK_B, XK_plus, XK_Greek_beta, XK_colon, 0, 0})); + keysyms.set(58, new ArrayBox({XK_m, XK_M, XK_percent, XK_Greek_mu, XK_1, 0, XK_ifonlyif})); + keysyms.set(59, new ArrayBox({XK_comma, 0, XK_quotedbl, XK_Greek_rho, XK_2, 0, 0})); + keysyms.set(60, new ArrayBox({XK_period, 0, XK_apostrophe, 0, XK_3, 0, XK_Greek_THETA})); + keysyms.set(61, new ArrayBox({XK_j, XK_J, XK_semicolon, XK_Greek_theta, XK_semicolon, 0, XK_variation})); + keysyms.set(62, new ArrayBox({XK_Shift_R, 0, XK_Shift_R})); + keysyms.set(63, new ArrayBox({XK_KP_Multiply, XK_KP_Multiply, 0, XK_multiply, 0, 0, 0})); + keysyms.set(64, new ArrayBox({XK_Alt_L, XK_Meta_L, XK_Meta_L})); + keysyms.set(65, new ArrayBox({XK_space, XK_space, XK_space, XK_nobreakspace, XK_0, 0, 0})); + keysyms.set(66, new ArrayBox({XK_ISO_Level3_Shift, XK_ISO_Level3_Shift, XK_Caps_Lock, XK_Caps_Lock})); + keysyms.set(67, new ArrayBox({XK_F1, 0, 0})); + keysyms.set(68, new ArrayBox({XK_F2, 0, 0})); + keysyms.set(69, new ArrayBox({XK_F3, 0, 0})); + keysyms.set(70, new ArrayBox({XK_F4, 0, 0})); + keysyms.set(71, new ArrayBox({XK_F5, 0, 0})); + keysyms.set(72, new ArrayBox({XK_F6, 0, 0})); + keysyms.set(73, new ArrayBox({XK_F7, 0, 0})); + keysyms.set(74, new ArrayBox({XK_F8, 0, 0})); + keysyms.set(75, new ArrayBox({XK_F9, 0, 0})); + keysyms.set(76, new ArrayBox({XK_F10, 0, 0})); + keysyms.set(77, new ArrayBox({XK_Tab, XK_ISO_Left_Tab, XK_equal, XK_approxeq, XK_notequal, 0, XK_identical})); + keysyms.set(78, new ArrayBox({XK_Scroll_Lock, 0, XK_Scroll_Lock})); + keysyms.set(79, new ArrayBox({XK_KP_7, 0, 0, 0, XK_KP_Home, XK_KP_Home, 0})); + keysyms.set(80, new ArrayBox({XK_KP_8, 0, XK_uparrow, XK_intersection, XK_KP_Up, XK_KP_Up, 0})); + keysyms.set(81, new ArrayBox({XK_KP_9, XK_KP_9, 0, 0, XK_KP_Prior, XK_KP_Prior, 0})); + keysyms.set(82, new ArrayBox({XK_KP_Subtract, XK_KP_Subtract, 0, 0, 0, 0, 0})); + keysyms.set(83, new ArrayBox({XK_KP_4, 0, XK_leftarrow, XK_includedin, XK_KP_Left, XK_KP_Left, 0})); + keysyms.set(84, new ArrayBox({XK_KP_5, XK_EuroSign, XK_brokenbar, 0, XK_KP_Begin, XK_KP_Begin, 0})); + keysyms.set(85, new ArrayBox({XK_KP_6, XK_KP_6, XK_rightarrow, XK_includes, XK_KP_Right, XK_KP_Right, 0})); + keysyms.set(86, new ArrayBox({XK_KP_Add, XK_KP_Add, XK_plusminus, 0, 0, 0, 0})); + keysyms.set(87, new ArrayBox({XK_KP_1, 0, 0, XK_lessthanequal, XK_KP_End, XK_KP_End, 0})); + keysyms.set(88, new ArrayBox({XK_KP_2, 0, XK_downarrow, XK_union, XK_KP_Down, XK_KP_Down, 0})); + keysyms.set(89, new ArrayBox({XK_KP_3, 0, 0, XK_greaterthanequal, XK_KP_Next, XK_KP_Next, 0})); + keysyms.set(90, new ArrayBox({XK_KP_0, 0, XK_percent, 0, XK_KP_Insert, XK_KP_Insert, 0})); + keysyms.set(91, new ArrayBox({XK_KP_Decimal, XK_comma, XK_period, XK_apostrophe, XK_KP_Delete, XK_KP_Delete, XK_quotedbl})); + keysyms.set(92, new ArrayBox({XK_ISO_Level3_Shift, 0, XK_ISO_Level3_Shift})); + keysyms.set(93, new ArrayBox({XK_Zenkaku_Hankaku, 0, XK_Zenkaku_Hankaku})); + keysyms.set(94, new ArrayBox({XK_ISO_Level5_Shift, 0, XK_ISO_Level5_Shift})); + keysyms.set(95, new ArrayBox({XK_F11, 0, 0})); + keysyms.set(96, new ArrayBox({XK_F12, 0, 0})); + keysyms.set(97, new ArrayBox({})); + keysyms.set(98, new ArrayBox({XK_Katakana, 0, XK_Katakana})); + keysyms.set(99, new ArrayBox({XK_Hiragana, 0, XK_Hiragana})); + keysyms.set(100, new ArrayBox({XK_Henkan_Mode, 0, XK_Henkan_Mode})); + keysyms.set(101, new ArrayBox({XK_Hiragana_Katakana, 0, XK_Hiragana_Katakana})); + keysyms.set(102, new ArrayBox({XK_Muhenkan, 0, XK_Muhenkan})); + keysyms.set(103, new ArrayBox({})); + keysyms.set(104, new ArrayBox({XK_KP_Enter, XK_KP_Enter, XK_KP_Enter, XK_KP_Enter, XK_KP_Enter, XK_KP_Enter, XK_KP_Enter})); + keysyms.set(105, new ArrayBox({XK_Control_R, 0, XK_Control_R})); + keysyms.set(106, new ArrayBox({XK_KP_Divide, XK_KP_Divide, XK_division, 0, 0, 0, 0})); + keysyms.set(107, new ArrayBox({XK_Print, XK_Sys_Req, XK_Sys_Req})); + keysyms.set(108, new ArrayBox({XK_ISO_Level5_Shift, 0, XK_ISO_Level5_Shift})); + keysyms.set(109, new ArrayBox({XK_Linefeed, 0, XK_Linefeed})); + keysyms.set(110, new ArrayBox({XK_Home, 0, XK_Home})); + keysyms.set(111, new ArrayBox({XK_Up, 0, XK_Up})); + keysyms.set(112, new ArrayBox({XK_Prior, 0, XK_Prior})); + keysyms.set(113, new ArrayBox({XK_Left, 0, XK_Left})); + keysyms.set(114, new ArrayBox({XK_Right, 0, XK_Right})); + keysyms.set(115, new ArrayBox({XK_End, 0, XK_End})); + keysyms.set(116, new ArrayBox({XK_Down, 0, XK_Down})); + keysyms.set(117, new ArrayBox({XK_Next, 0, XK_Next})); + keysyms.set(118, new ArrayBox({XK_Insert, 0, XK_Insert})); + keysyms.set(119, new ArrayBox({XK_Delete, 0, XK_Delete})); + keysyms.set(120, new ArrayBox({})); + keysyms.set(121, new ArrayBox({0, 0, 0})); + keysyms.set(122, new ArrayBox({0, 0, 0})); + keysyms.set(123, new ArrayBox({0, 0, 0})); + keysyms.set(124, new ArrayBox({0, 0, 0})); + keysyms.set(125, new ArrayBox({XK_KP_Equal, 0, XK_KP_Equal})); + keysyms.set(126, new ArrayBox({XK_plusminus, 0, XK_plusminus})); + keysyms.set(127, new ArrayBox({XK_Pause, XK_Break, XK_Break})); + keysyms.set(128, new ArrayBox({})); + keysyms.set(129, new ArrayBox({XK_KP_Separator, 0, XK_KP_Separator})); + keysyms.set(130, new ArrayBox({XK_Hangul, 0, XK_Hangul})); + keysyms.set(131, new ArrayBox({XK_Hangul_Hanja, 0, XK_Hangul_Hanja})); + keysyms.set(132, new ArrayBox({})); + keysyms.set(133, new ArrayBox({XK_Super_L, 0, XK_Super_L})); + keysyms.set(134, new ArrayBox({XK_Super_R, 0, XK_Super_R})); + keysyms.set(135, new ArrayBox({XK_Menu, 0, XK_Menu})); + keysyms.set(136, new ArrayBox({XK_Cancel, 0, XK_Cancel})); + keysyms.set(137, new ArrayBox({XK_Redo, 0, XK_Redo})); + keysyms.set(138, new ArrayBox({0, 0, 0})); + keysyms.set(139, new ArrayBox({XK_Undo, 0, XK_Undo})); + keysyms.set(140, new ArrayBox({0, 0, 0})); + keysyms.set(141, new ArrayBox({0, 0, 0})); + keysyms.set(142, new ArrayBox({0, 0, 0})); + keysyms.set(143, new ArrayBox({0, 0, 0})); + keysyms.set(144, new ArrayBox({XK_Find, 0, XK_Find})); + keysyms.set(145, new ArrayBox({0, 0, 0})); + keysyms.set(146, new ArrayBox({XK_Help, 0, XK_Help})); + keysyms.set(147, new ArrayBox({0, 0, 0})); + keysyms.set(148, new ArrayBox({0, 0, 0})); + keysyms.set(149, new ArrayBox({})); + keysyms.set(150, new ArrayBox({0, 0, 0})); + keysyms.set(151, new ArrayBox({0, 0, 0})); + keysyms.set(152, new ArrayBox({0, 0, 0})); + keysyms.set(153, new ArrayBox({0, 0, 0})); + keysyms.set(154, new ArrayBox({})); + keysyms.set(155, new ArrayBox({0, 0, 0})); + keysyms.set(156, new ArrayBox({0, 0, 0})); + keysyms.set(157, new ArrayBox({0, 0, 0})); + keysyms.set(158, new ArrayBox({0, 0, 0})); + keysyms.set(159, new ArrayBox({0, 0, 0})); + keysyms.set(160, new ArrayBox({0, 0, 0})); + keysyms.set(161, new ArrayBox({})); + keysyms.set(162, new ArrayBox({0, 0, 0})); + keysyms.set(163, new ArrayBox({0, 0, 0})); + keysyms.set(164, new ArrayBox({0, 0, 0})); + keysyms.set(165, new ArrayBox({0, 0, 0})); + keysyms.set(166, new ArrayBox({0, 0, 0})); + keysyms.set(167, new ArrayBox({0, 0, 0})); + keysyms.set(168, new ArrayBox({})); + keysyms.set(169, new ArrayBox({0, 0, 0})); + keysyms.set(170, new ArrayBox({0, 0, 0})); + keysyms.set(171, new ArrayBox({0, 0, 0})); + keysyms.set(172, new ArrayBox({0, 0, 0})); + keysyms.set(173, new ArrayBox({0, 0, 0})); + keysyms.set(174, new ArrayBox({0, 0, 0})); + keysyms.set(175, new ArrayBox({0, 0, 0})); + keysyms.set(176, new ArrayBox({0, 0, 0})); + keysyms.set(177, new ArrayBox({0, 0, 0})); + keysyms.set(178, new ArrayBox({})); + keysyms.set(179, new ArrayBox({0, 0, 0})); + keysyms.set(180, new ArrayBox({0, 0, 0})); + keysyms.set(181, new ArrayBox({0, 0, 0})); + keysyms.set(182, new ArrayBox({0, 0, 0})); + keysyms.set(183, new ArrayBox({})); + keysyms.set(184, new ArrayBox({})); + keysyms.set(185, new ArrayBox({0, 0, 0})); + keysyms.set(186, new ArrayBox({0, 0, 0})); + keysyms.set(187, new ArrayBox({XK_parenleft, 0, XK_parenleft})); + keysyms.set(188, new ArrayBox({XK_parenright, 0, XK_parenright})); + keysyms.set(189, new ArrayBox({0, 0, 0})); + keysyms.set(190, new ArrayBox({XK_Redo, 0, XK_Redo})); + keysyms.set(191, new ArrayBox({})); + keysyms.set(192, new ArrayBox({})); + keysyms.set(193, new ArrayBox({})); + keysyms.set(194, new ArrayBox({})); + keysyms.set(195, new ArrayBox({})); + keysyms.set(196, new ArrayBox({})); + keysyms.set(197, new ArrayBox({})); + keysyms.set(198, new ArrayBox({})); + keysyms.set(199, new ArrayBox({})); + keysyms.set(200, new ArrayBox({})); + keysyms.set(201, new ArrayBox({})); + keysyms.set(202, new ArrayBox({})); + keysyms.set(203, new ArrayBox({XK_Mode_switch, 0, XK_Mode_switch})); + keysyms.set(204, new ArrayBox({0, XK_Alt_L, XK_Alt_L})); + keysyms.set(205, new ArrayBox({0, XK_Meta_L, XK_Meta_L})); + keysyms.set(206, new ArrayBox({0, XK_Super_L, XK_Super_L})); + keysyms.set(207, new ArrayBox({0, XK_Hyper_L, XK_Hyper_L})); + keysyms.set(208, new ArrayBox({0, 0, 0})); + keysyms.set(209, new ArrayBox({0, 0, 0})); + keysyms.set(210, new ArrayBox({0, 0, 0})); + keysyms.set(211, new ArrayBox({0, 0, 0})); + keysyms.set(212, new ArrayBox({})); + keysyms.set(213, new ArrayBox({0, 0, 0})); + keysyms.set(214, new ArrayBox({0, 0, 0})); + keysyms.set(215, new ArrayBox({0, 0, 0})); + keysyms.set(216, new ArrayBox({0, 0, 0})); + keysyms.set(217, new ArrayBox({})); + keysyms.set(218, new ArrayBox({XK_Print, 0, XK_Print})); + keysyms.set(219, new ArrayBox({})); + keysyms.set(220, new ArrayBox({0, 0, 0})); + keysyms.set(221, new ArrayBox({})); + keysyms.set(222, new ArrayBox({})); + keysyms.set(223, new ArrayBox({0, 0, 0})); + keysyms.set(224, new ArrayBox({})); + keysyms.set(225, new ArrayBox({0, 0, 0})); + keysyms.set(226, new ArrayBox({})); + keysyms.set(227, new ArrayBox({0, 0, 0})); + keysyms.set(228, new ArrayBox({})); + keysyms.set(229, new ArrayBox({0, 0, 0})); + keysyms.set(230, new ArrayBox({})); + keysyms.set(231, new ArrayBox({XK_Cancel, 0, XK_Cancel})); + keysyms.set(232, new ArrayBox({0, 0, 0})); + keysyms.set(233, new ArrayBox({0, 0, 0})); + keysyms.set(234, new ArrayBox({0, 0, 0})); + keysyms.set(235, new ArrayBox({0, 0, 0})); + keysyms.set(236, new ArrayBox({0, 0, 0})); + keysyms.set(237, new ArrayBox({0, 0, 0})); + keysyms.set(238, new ArrayBox({0, 0, 0})); + keysyms.set(239, new ArrayBox({0, 0, 0})); + keysyms.set(240, new ArrayBox({0, 0, 0})); + keysyms.set(241, new ArrayBox({0, 0, 0})); + keysyms.set(242, new ArrayBox({0, 0, 0})); + keysyms.set(243, new ArrayBox({0, 0, 0})); + keysyms.set(244, new ArrayBox({0, 0, 0})); + keysyms.set(245, new ArrayBox({0, 0, 0})); + keysyms.set(246, new ArrayBox({0, 0, 0})); + keysyms.set(247, new ArrayBox({})); + keysyms.set(248, new ArrayBox({})); + keysyms.set(249, new ArrayBox({})); + keysyms.set(250, new ArrayBox({})); + keysyms.set(251, new ArrayBox({})); + keysyms.set(252, new ArrayBox({})); + keysyms.set(253, new ArrayBox({})); + keysyms.set(254, new ArrayBox({})); + keysyms.set(255, new ArrayBox({})); + + + return keysyms; + } + + public void generateKeyevents() { + HBox[] hboxes = { + new HBox(false, 0), + new HBox(false, 0), + new HBox(false, 0), + new HBox(false, 0), + new HBox(false, 0) + }; + this.pack_start( hboxes[0], false, true, 0 ); + this.pack_start( hboxes[1], false, true, 0 ); + this.pack_start( hboxes[2], false, true, 0 ); + this.pack_start( hboxes[3], false, true, 0 ); + this.pack_start( hboxes[4], false, true, 0 ); + + double winWidthUnscaled = 1000.0; + double winHeightUnscaled = 220.0; + if( winMain.config.get("display_numblock")=="0" ) + winWidthUnscaled -= winMain.numblock_width; + int width, height; + winMain.get_size2(out width, out height); + + double scaleX = width/winWidthUnscaled; + double scaleY = height/winHeightUnscaled; + + double posXUnscaled = 0.0; + double posYUnscaled = 0.0; + int posX = 0; + int posY = 0; + + GLib.stdout.printf(@"$winWidthUnscaled , $width , $scaleX\n"); + +//++ Top row ++ +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 49, false, winMain, hboxes[0], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 10, false, winMain, hboxes[0], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 11, false, winMain, hboxes[0], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 12, false, winMain, hboxes[0], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 13, false, winMain, hboxes[0], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 14, false, winMain, hboxes[0], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 15, false, winMain, hboxes[0], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 16, false, winMain, hboxes[0], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 17, false, winMain, hboxes[0], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 18, false, winMain, hboxes[0], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 19, false, winMain, hboxes[0], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 20, false, winMain, hboxes[0], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 21 , false, winMain, hboxes[0], 0); + + if( winMain.config.get("display_numblock")!="0" ){ + + }else{ + +scaledBox(78.0-1.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 22 , true, winMain, hboxes[0], 0); + } + //Reset right shift. + posXUnscaled = 0.0; + posX = 0; +//++ End top row ++ +//++ Second row ++ +scaledBox(60.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 23 , false, winMain, hboxes[1], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 24 , false, winMain, hboxes[1], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 25 , false, winMain, hboxes[1], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 26 , false, winMain, hboxes[1], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 27 , false, winMain, hboxes[1], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 28 , false, winMain, hboxes[1], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 29 , false, winMain, hboxes[1], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 30 , false, winMain, hboxes[1], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 31 , false, winMain, hboxes[1], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 32 , false, winMain, hboxes[1], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 33 , false, winMain, hboxes[1], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 34 , false, winMain, hboxes[1], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 35 , false, winMain, hboxes[1], 0); +//Halve of Return/Enter +scaledBox(62.0-1,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 36 , true, winMain, hboxes[1], 0); + //Reset right shift. + posXUnscaled = 0.0; + posX = 0; + +//++ End second row ++ +//++ third row ++ +//left mod3 +scaledBox(73.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 2/*37*/ , false, winMain, hboxes[2], 1); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 38 , false, winMain, hboxes[2], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 39 , false, winMain, hboxes[2], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 40 , false, winMain, hboxes[2], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 41 , false, winMain, hboxes[2], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 42 , false, winMain, hboxes[2], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 43 , false, winMain, hboxes[2], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 44 , false, winMain, hboxes[2], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 45 , false, winMain, hboxes[2], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 46 , false, winMain, hboxes[2], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 47 , false, winMain, hboxes[2], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 48 , false, winMain, hboxes[2], 0); +//right mod3 +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 2/*51*/ , false, winMain, hboxes[2], 1); +//Second halve of Enter/Return +scaledBox(49.0-1,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 36 , true, winMain, hboxes[2], 0); + //Reset right shift. + posXUnscaled = 0.0; + posX = 0; +//++ End third row ++ +//++ fourth row ++ +//left shift +scaledBox(52.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 1/*50*/ , false, winMain, hboxes[3], 1); +//mod4 +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 3/*94*/ , false, winMain, hboxes[3], 1); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 52 , false, winMain, hboxes[3], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 53 , false, winMain, hboxes[3], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 54 , false, winMain, hboxes[3], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 55 , false, winMain, hboxes[3], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 56 , false, winMain, hboxes[3], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 57 , false, winMain, hboxes[3], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 58 , false, winMain, hboxes[3], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 59 , false, winMain, hboxes[3], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 60 , false, winMain, hboxes[3], 0); +scaledBox(44.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 61 , false, winMain, hboxes[3], 0); +//right shift +scaledBox(114.0-1,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 1 /*62*/ , true, winMain, hboxes[3], 1); + //Reset right shift. + posXUnscaled = 0.0; + posX = 0; +//++ End fourth row ++ +//++ fivth row ++ +//left ctrl, 37 +scaledBox(61.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 4/*37*/ , false, winMain, hboxes[4], 2); +//free space +scaledBox(48.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , -1 , false, winMain, hboxes[4], 3); +//alt +scaledBox(61.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 5/*64*/ , false, winMain, hboxes[4], 2); +//space +scaledBox(316.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 65 , false, winMain, hboxes[4], 0); +//mod4 +scaledBox(61.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 3/*94*/ , false, winMain, hboxes[4], 1); +//free space +scaledBox(40.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , -1 , false, winMain, hboxes[4], 3); +// right ctrl +scaledBox(61.0,44.0,ref posXUnscaled, ref posYUnscaled, ref posX, ref posY, scaleX, scaleY , 4/*105*/ , false, winMain, hboxes[4], 2); + +//++ End fivth row ++ + } + + + /* + Gibt scalierte EventBox zurück. Damit sich die Rundungfehler durch int-Cast nicht aufzusummieren, + basieren die Werte auf der bis zu diesem Zeitpunkt zu erwartenden Gesamtbreite/höhe. +*/ + private KeyEventBox scaledBox(double widthUnscaled, double heightUnscaled, + ref double posXUnscaled, ref double posYUnscaled, + ref int posX, ref int posY, + double scaleX, double scaleY, + int keycode, bool vertical, NeoWindow winMain, Box box, int boxtype ){ + + int width = (int) GLib.Math.floor( (posXUnscaled + widthUnscaled)*scaleX - posX ) ; + int height = (int) GLib.Math.floor( (posYUnscaled + heightUnscaled)*scaleY - posY); + + if( vertical){ + posYUnscaled += heightUnscaled; + posY += height; + }else{ + posXUnscaled += widthUnscaled; + posX += width; + } + + KeyEventBox keybox; + if( boxtype == 0 ){ + // Normale Taste + ArrayBox ks = this.keysyms.get(keycode); + keybox = new KeyEventBox(winMain, width, height, ref ks.val ); + this.keyBoxes.set(keycode, keybox); + box.pack_start(keybox, false, true, 0 ); + }else if( boxtype == 1){ + // Modifier, die andere Buchstabenebenen aktivieren. Zusätzlich Ebenen-Bild einblenden. + keybox = new KeyEventBox.modifier(winMain, width, height, keycode /*=modifier array index*/ ); + this.keyBoxes.set(keycode, keybox); + box.pack_start(keybox, false, true, 0 ); + }else if( boxtype == 2){ + //Andere Modifier (CTRL, Alt,... ) + keybox = new KeyEventBox.modifier2(winMain, width, height, keycode /*modifier array index */ ); + this.keyBoxes.set(keycode, keybox); + box.pack_start(keybox, false, true, 0 ); + }else{ + // Fläche ohne Funktion + keybox = new KeyEventBox.freeArea(winMain, width, height ); + this.keyBoxes.set(keycode, keybox); + box.pack_start(keybox, false, true, 0 ); + } + + + return keybox; + } + + +} //End Class KeyOverlay + + + +public class KeyEventBox : EventBox{ + //private double widthPercent; + //private double heightPercent; + //static bool flip = true; + + private uint[] keysym;// or + private int modifier_index; + + private NeoWindow winMain; + private int width; + private int height; + private string cmd; + + /* + Die Reihenfolge der Zeichen in keysyms passt nicht + zur Nummerierung der Ebenen in winMain. Mit diesem Array + wird der Wert permutiert. + */ + private static const short[] layer_permutation = {0,1,2,3,5,4,7}; + + private KeyEventBox.all(NeoWindow winMain, int width, int height){ + this.winMain = winMain; + this.width = width; + this.height = height; + + /* + if( flip ){ + flip = false; + this.set_visible_window(false); + }else{ + flip = true; + } + */ + this.set_visible_window(false); + } + + public KeyEventBox(NeoWindow winMain, int width, int height , ref uint[] keysym){ + //base(); + this.all(winMain, width, height); + this.keysym = keysym; + + GLib.stdout.printf("Ww: %i, Wh: %i\n", width, height); + + this.button_press_event.connect ((event) => { + uint ks = this.keysym[this.layer_permutation[winMain.ebene]-1]; + int modi = winMain.active_modifier[4]*winMain.MODIFIER_MASK[4] + + winMain.active_modifier[5]*winMain.MODIFIER_MASK[5]; + if( ks < 1 ) return false; + this.cmd = @"./keysend/keysend $(ks) $(modi)"; + GLib.stdout.printf("%s\n", this.cmd); + Posix.system( this.cmd ); + return false; + }); + + } + + public KeyEventBox.modifier(NeoWindow winMain, int width, int height , int modifier_index ){ + this.all(winMain, width, height); + this.modifier_index = modifier_index; + + this.button_press_event.connect ((event) => { + if( winMain.active_modifier[this.modifier_index] == 0){ + winMain.active_modifier[this.modifier_index] = 1; + winMain.status.set_label(@"Activate Modifier $(this.modifier_index)"); + }else{ + winMain.active_modifier[this.modifier_index] = 0; + winMain.status.set_label(@"Deactivate Modifier $(this.modifier_index)"); + } + winMain.redraw(); + + return false; + }); + } + + public KeyEventBox.modifier2(NeoWindow winMain, int width, int height , int modifier_index ){ + this.all(winMain, width, height); + this.modifier_index = modifier_index; + + this.button_press_event.connect ((event) => { + if( winMain.active_modifier[this.modifier_index] == 0){ + winMain.active_modifier[this.modifier_index] = 1; + //deactivate modifier, which select other charakters + //winMain.active_modifier[0] = 0;//egal + winMain.active_modifier[1] = 0; + winMain.active_modifier[2] = 0; + winMain.active_modifier[3] = 0; + winMain.status.set_label(@"Activate Modifier $(this.modifier_index)"); + }else{ + winMain.active_modifier[this.modifier_index] = 0; + winMain.status.set_label(@"Deactivate Modifier $(this.modifier_index)"); + } + winMain.redraw(); + return false; + }); + } + + public KeyEventBox.freeArea(NeoWindow winMain, int width, int height ){ + this.all(winMain, width, height); + } + /* + * This method Gtk+ is calling on a widget to ask + * the widget how large it wishes to be. It's not guaranteed + * that Gtk+ will actually give this size to the widget. + */ + public override void size_request (out Gtk.Requisition requisition) { + //int width, height; + // In this case, we say that we want to be as big as the + // text is, plus a little border around it. + //this.layout.get_size (out width, out height); + requisition.width = width ;// / Pango.SCALE; + requisition.height = height; // / Pango.SCALE; + + GLib.stdout.printf("W: %i, H: %i, Sc: %f\n",width, height, Pango.SCALE); + } + + + + } +} + diff --git a/keybinding-manager.vala b/keybinding-manager.vala new file mode 100644 index 0000000..9d3ded9 --- /dev/null +++ b/keybinding-manager.vala @@ -0,0 +1,310 @@ +namespace NeoLayoutViewer{ + /** + * Modification of http://www.linux-nantes.org/~fmonnier/ocaml/Xlib/doc/Xlib.html by + * Oliver Sauder + */ + public class KeybindingManager : GLib.Object + { + private NeoWindow neo_win; + /** + * list of binded keybindings + */ + private Gee.List bindings = new Gee.ArrayList(); + private Gee.List modifier_bindings = new Gee.ArrayList(); + /** + * locked modifiers used to grab all keys whatever lock key + * is pressed. + */ + private static uint[] lock_modifiers = { + 0, + Gdk.ModifierType.MOD2_MASK, // NUM_LOCK + Gdk.ModifierType.LOCK_MASK, // CAPS_LOCK + Gdk.ModifierType.MOD5_MASK, // SCROLL_LOCK + Gdk.ModifierType.MOD2_MASK|Gdk.ModifierType.LOCK_MASK, + Gdk.ModifierType.MOD2_MASK|Gdk.ModifierType.MOD5_MASK, + Gdk.ModifierType.LOCK_MASK|Gdk.ModifierType.MOD5_MASK, + Gdk.ModifierType.MOD2_MASK|Gdk.ModifierType.LOCK_MASK|Gdk.ModifierType.MOD5_MASK + }; + + + /** + * Helper class to store keybinding + */ + private class Keybinding + { + public Keybinding(string accelerator, int keycode, + Gdk.ModifierType modifiers, KeybindingHandlerFunc handler) + { + this.accelerator = accelerator; + this.keycode = keycode; + this.modifiers = modifiers; + this.handler = handler; + } + + public string accelerator { get; set; } + public int keycode { get; set; } + public Gdk.ModifierType modifiers { get; set; } + public KeybindingHandlerFunc handler { get; set; } + } + + + /** + * Helper class to store second set of keybindings (modifier) + */ + private class ModifierKeybinding + { + public ModifierKeybinding(string accelerator, int keycode, + Gdk.ModifierType modifiers, int ebene, KeybindingHandlerFunc handler) + { + this.accelerator = accelerator; + this.keycode = keycode; + this.ebene = ebene; + this.modifiers = modifiers; + this.handler = handler; + } + + public string accelerator { get; set; } + public int keycode { get; set; } + public int ebene { get; set; } + public Gdk.ModifierType modifiers { get; set; } + public KeybindingHandlerFunc handler { get; set; } + } + + /** + * Keybinding func needed to bind key to handler + * + * @param event passing on gdk event + */ + public delegate void KeybindingHandlerFunc(Gdk.Event event); + + public KeybindingManager(NeoWindow neo_win) + { + this.neo_win = neo_win; + // init filter to retrieve X.Events + Gdk.Window rootwin = Gdk.get_default_root_window(); + if(rootwin != null) { + rootwin.add_filter(event_filter); + } + + +//some tests +/* + X.Display display = Gdk.x11_drawable_get_xdisplay(rootwin); + X.ModifierKeymap modmap = display.get_modifier_mapping (); + debug("Max mod: %i\n".printf(modmap.max_keypermod)); +for(int i=0; i remove_bindings = new Gee.ArrayList(); + foreach(Keybinding binding in bindings) { + if(str_equal(accelerator, binding.accelerator)) { + foreach(uint lock_modifier in lock_modifiers) { + display.ungrab_key(binding.keycode, binding.modifiers, xid); + } + remove_bindings.add(binding); + } + } + // remove unbinded keys + bindings.remove_all(remove_bindings); + } + + + public void unbind2(int keycode) + { + //debug("Unbinding key\n "); + + Gdk.Window rootwin = Gdk.get_default_root_window(); + unowned X.Display display = Gdk.x11_drawable_get_xdisplay(rootwin); + X.ID xid = Gdk.x11_drawable_get_xid(rootwin); + + // unbind all keys with given accelerator + Gee.List remove_bindings = new Gee.ArrayList(); + foreach(ModifierKeybinding binding in modifier_bindings) { + if(keycode == binding.keycode) { + display.ungrab_key(binding.keycode, binding.modifiers, xid); + remove_bindings.add(binding); + } + } + // remove unbinded keys + bindings.remove_all(remove_bindings); + } + + + + /** + * Event filter method needed to fetch X.Events + */ + public Gdk.FilterReturn event_filter(Gdk.XEvent gdk_xevent, Gdk.Event gdk_event) + { + Gdk.FilterReturn filter_return = Gdk.FilterReturn.CONTINUE; + //Gdk.FilterReturn filter_return = Gdk.FilterReturn.REMOVE; + + void* pointer = &gdk_xevent; + X.Event* xevent = (X.Event*) pointer; + +if(xevent->type == X.EventType.KeyPress) { + foreach(Keybinding binding in bindings) { + // remove NumLock, CapsLock and ScrollLock from key state + uint event_mods = xevent.xkey.state & ~ (lock_modifiers[7]); + if(xevent->xkey.keycode == binding.keycode && event_mods == binding.modifiers) { + // call all handlers with pressed key and modifiers + binding.handler(gdk_event); + } + } + } + + if(xevent->type == X.EventType.KeyPress) { + uint event_mods = xevent.xkey.state; + foreach(ModifierKeybinding binding in modifier_bindings) { + if(xevent->xkey.keycode == binding.keycode) { + //neo_win.external_key_press(binding.ebene,(int)event_mods); + neo_win.active_modifier[binding.ebene] = 1; + neo_win.redraw(); + // call all handlers with pressed key and modifiers + binding.handler(gdk_event); + //send_event_again(Gdk.get_default_root_window(), binding, *xevent); + } + } + } + + if(xevent->type == X.EventType.KeyRelease) { + uint event_mods = xevent.xkey.state; + + foreach(ModifierKeybinding binding in modifier_bindings) { + if(xevent->xkey.keycode == binding.keycode) { + //neo_win.external_key_release(0,(int)event_mods); + neo_win.active_modifier[binding.ebene] = 0; + neo_win.redraw(); + // call all handlers with pressed key and modifiers + binding.handler(gdk_event); + //send_event_again(Gdk.get_default_root_window(), binding, *xevent); + } + } + } + + +debug("Filter %u\n".printf(xevent.xkey.keycode)); + + send_event_again(Gdk.get_default_root_window(), *xevent); + + return filter_return; + } + + + private void send_event_again(Gdk.Window rootwin, X.Event xevent){ + + if(rootwin != null) { + unowned X.Display display = Gdk.x11_drawable_get_xdisplay(rootwin); + X.ID xid = Gdk.x11_drawable_get_xid(rootwin); + foreach(ModifierKeybinding binding in modifier_bindings){ + display.ungrab_key(binding.keycode, binding.modifiers, xid); + } + + //rootwin.remove_filter(event_filter); +debug("Send Event again %u\n".printf(xevent.xkey.state)); + display.send_event(xevent.xkey.window,true,xevent.xkey.state,ref xevent); + //rootwin.add_filter(event_filter); + + foreach(ModifierKeybinding binding in modifier_bindings){ + // display.grab_key(binding.keycode, 0, xid, false, X.GrabMode.Async, X.GrabMode.Async); + } + } + + } + + } +} diff --git a/neo2.vala b/neo2.vala new file mode 100644 index 0000000..93a43e8 --- /dev/null +++ b/neo2.vala @@ -0,0 +1,435 @@ +using Gtk; +using Gdk; +using X; //keysym.h +using Posix;//system-calls + +namespace NeoLayoutViewer{ + + public class NeoWindow : Gtk.Window { + + private Gtk.Image image; + public Gtk.Label status; + private Gdk.Pixbuf[] image_buffer; + public Gee.HashMap config; + + public int ebene; + public int[] active_modifier; + public int numblock_width; + //private Button button; + private bool minimized; + private int position_num; + private int[] position_cycle; + + /* Die Neo-Modifier unterscheiden sich zum Teil von den Normalen, für die Konstanten definiert sind. Bei der Initialisierung werden aus den Standardkonstanen die Konstenen für die Ebenen 1-6 berechnet.*/ + public int[] NEO_MODIFIER_MASK; + public int[] MODIFIER_MASK; + +// /* Modifier-codes für CTLR, ALT, ... */ +// public int[] OTHER_MODIFIER_MASK; + +/* Die Keycodes von ShiftL, ShiftR, Mod3 (Alt Gr,<) und Mod4 (CapsLock, #)... in der Uni schon mal keine Übereinstimmung*/ + //private int[] MODIFIER_KEY_CODES = {65505,65506,65027,65041};//home + //private int[] MODIFIER_KEY_CODES = {65505,65506,65406,65027};//uni + +/* Falls ein Modifier (oder eine andere Taste) gedrückt wird und schon Modifier gedrückt sind, gibt die Map an, welche Ebene dann aktiviert ist. */ + private short[,] MODIFIER_MAP = { + {0,1,2,3,4,5}, + {1,1,4,3,4,5}, + {2,4,2,5,4,5}, + {3,3,5,3,4,5} }; + + /* [0,1]^3->{0,5}, Bildet aktive Modifier auf angezeigte Ebene ab. + Interpretationsreihenfolge der Dimensionen: Shift,Neo-Mod3, Neo-Mod4. */ + private short[,,] MODIFIER_MAP2 = { + { {0 , 3}, {2 , 5 } }, // 000, 001; 010, 011 + { {1 , 3}, {4 , 5}} // 100, 101; 110, 111 + }; + +/* Analog zu oben für den Fall, dass eine Taste losgelassen wird. Funktioniert nicht immer. + Ist beispielsweise ShiftL und ShiftR gedrückt und eine wird losgelassen, so wechelt die Anzeige zur ersten Ebene. + Die Fehler sind imo zu vernachlässigen. +*/ + private short[,] MODIFIER_MAP_RELEASE = { + {0,0,0,0,0,0}, + {0,0,2,3,2,5}, + {0,1,0,3,1,3}, + {0,1,2,0,4,2} }; + + public NeoWindow (string sebene, Gee.HashMap config) { + this.config = config; + this.minimized = true; + + this.NEO_MODIFIER_MASK = { + 0, + Gdk.ModifierType.SHIFT_MASK, //1 + Gdk.ModifierType.MOD5_MASK+Gdk.ModifierType.LOCK_MASK, //128+2 + Gdk.ModifierType.MOD3_MASK, //32 + Gdk.ModifierType.MOD5_MASK+Gdk.ModifierType.LOCK_MASK+Gdk.ModifierType.SHIFT_MASK, //128+2+1 + Gdk.ModifierType.MOD5_MASK+Gdk.ModifierType.LOCK_MASK+Gdk.ModifierType.MOD3_MASK //128+2+32 + }; + /* + this.OTHER_MODIFIER_MASK = { + Gdk.ModifierType.CONTROL_MASK, + Gdk.ModifierType.MOD1_MASK + };*/ + this.MODIFIER_MASK = { + 0, + Gdk.ModifierType.SHIFT_MASK, //1 + Gdk.ModifierType.MOD5_MASK,//128 + Gdk.ModifierType.MOD3_MASK, //32 + Gdk.ModifierType.CONTROL_MASK, + Gdk.ModifierType.MOD1_MASK // Alt-Mask do not work :-( + }; + this.active_modifier = {0,0,0,0,0,0}; + + this.position_num = int.max(int.min(int.parse(config.get("position")),9),1); + //Anlegen des Arrays, welches den Positionsdurchlauf beschreibt. + try{ + var space = new Regex(" "); + string[] split = space.split(config.get("position_cycle")); + position_cycle = new int[int.max(9,split.length)]; + for(int i=0;i6) {this.ebene = 1; } + + //Lade die Pngs der sechs Ebenen + this.load_image_buffer(); + this.image = new Gtk.Image();//.from_pixbuf(this.image_buffer[ebene]); + // Create an image and render first page to image + //var pixbuf = new Gdk.Pixbuf (Gdk.Colorspace.RGB, false, 8, 800, 600); + render_page (); + + var fixed = new Fixed(); + add(fixed); + + fixed.put(this.image, 0, 0); + fixed.put( new KeyOverlay(this) , 0, 0); + + this.status = new Label(""); + fixed.put( status, 2, 2 ); + + //Fenstereigenschaften setzen + this.key_press_event.connect (on_key_pressed); + this.destroy.connect (Gtk.main_quit); + + this.set_gravity(Gdk.Gravity.SOUTH); + //this.move(-100,-100); + /*GdkGeometry size_hints = { + 100, 50, 0, 0, 100, 50, 10, 10, 0.0, 0.0, GDK_GRAVITY_NORTH_WEST + }; + + gtk_window_set_geometry_hints (GTK_WINDOW (this), this, &size_hints, + GDK_HINT_MIN_SIZE | GDK_HINT_BASE_SIZE | GDK_HINT_RESIZE_INC); + */ + //this.window_position = WindowPosition.CENTER; + + //this.default_height = int.parse( config.get("height") ); + //this.default_width = int.parse( config.get("width") ); + this.decorated = false; + //this.allow_grow = false; + //this.allow_shrink = false; + this.skip_taskbar_hint = true; + + this.show_all(); + + //Move ist erst nach show_all() erfolgreich + this.numkeypad_move(int.parse(config.get("position"))); + + //Icon des Fensters + this.icon = this.image_buffer[0]; + + //Nicht selektierbar (für virtuelle Tastatur) + this.set_accept_focus(false); + } + + public override void show_all(){ + this.minimized = false; + base.show_all(); + //this.present(); + //set_visible(true); + this.numkeypad_move(this.position_num); + + if( config.get("on_top")=="1") + this.set_keep_above(true); + else + this.present(); + } + + public override void hide_all(){ + this.minimized = true; + base.hide_all(); + //set_visible(false); + } + + public bool toggle(){ + if(this.minimized) show_all(); + else hide_all(); + return this.minimized; + } + + /* Falsche Werte bei „Tiled Window Managern“. */ + public void get_size2(out int width, out int height){ + width = this.image_buffer[1].width; + height = this.image_buffer[1].height; + } + + public void numkeypad_move(int pos){ + int screen_width = this.screen.width(); + int screen_height = this.screen.height(); + int x,y,w,h; + this.get_size(out w,out h); + + switch (pos){ + case 0: //Zur nächsten Position wechseln + numkeypad_move(this.position_cycle[this.position_num-1]); + return; + case 7: + x = 0; + y = 0; + break; + case 8: + x = (screen_width-w)/2; + y = 0; + break; + case 9: + x = screen_width-w; + y = 0; + break; + case 4: + x = 0; + y = (screen_height-h)/2; + break; + case 5: + x = (screen_width-w)/2; + y = (screen_height-h)/2; + break; + case 6: + x = screen_width-w; + y = (screen_height-h)/2; + break; + case 1: + x = 0; + y = screen_height-h; + break; + case 2: + x = (screen_width-w)/2; + y = screen_height-h; + break; + //case 3: //=default case + // ; + default: + x = screen_width-w; + y = screen_height-h; + break; + } + + this.position_num = pos; + this.move(x,y); + } + + public Gdk.Pixbuf open_image (int ebene) { + var bildpfad = "assets/neo2.1/tastatur_neo_Ebene%i.png".printf(ebene); + return open_image_str(bildpfad); + //return new Image_from_pixpuf(open_image_str(bildpfad)); + } + + public Gdk.Pixbuf open_image_str (string bildpfad) { + try { + return new Gdk.Pixbuf.from_file (bildpfad); + } catch (Error e) { + error ("%s", e.message); + } + } + + public void load_image_buffer () { + this.image_buffer = new Gdk.Pixbuf[7]; + this.image_buffer[0] = open_image_str("assets/icons/Neo-Icon.png"); + + int screen_width = this.screen.width(); + //int screen_height = this.screen.height(); + int max_width = (int) ( double.parse( this.config.get("max_width") )*screen_width ); + int min_width = (int) ( double.parse( this.config.get("min_width") )*screen_width ); + int width = int.min(int.max(int.parse( config.get("width") ),min_width),max_width); + int w,h; + + for (int i=1; i<7; i++){ + this.image_buffer[i] = open_image(i); + + //Numpad-Teil abschneiden, falls gefordert + this.numblock_width = int.parse(config.get("numblock_width")); + if( config.get("display_numblock")=="0" ){ + var tmp = new Gdk.Pixbuf(image_buffer[i].colorspace,image_buffer[i].has_alpha,image_buffer[i].bits_per_sample, image_buffer[i].width-numblock_width ,image_buffer[i].height); + this.image_buffer[i].copy_area(0,0,tmp.width,tmp.height,tmp,0,0); + this.image_buffer[i] = tmp; + } + + //Bilder einmaling beim Laden skalieren. (Keine spätere Skalierung durch Größenänderung des Fensters) + w = this.image_buffer[i].width; + h = this.image_buffer[i].height; + this.image_buffer[i] = this.image_buffer[i].scale_simple(width, h*width/w,Gdk.InterpType.BILINEAR); + } + } + + private bool on_key_pressed (Widget source, Gdk.EventKey key) { + // If the key pressed was q, quit, else show the next page + if (key.str == "q") { + Gtk.main_quit (); + } + + if (key.str == "h") { + this.hide_all(); + } + + /* Erste Auswahlvariante: Zahlen 1-6 */ + var ebene_tmp = int.parse(key.str); + if(ebene_tmp>0 && ebene_tmp<7) { + if(this.ebene != ebene_tmp){ + this.ebene = ebene_tmp; + render_page (); + } + } + /*else{ + //Finde die aktuelle Taste und die derzeit gedrückten Modifier + int iet1 = 0; + int iet2 = 0; +debug("%u".printf(key.keyval)); + if( key.keyval == MODIFIER_KEY_CODES[0] || key.keyval == MODIFIER_KEY_CODES[1]){ + iet1=1; + }else if( key.keyval == MODIFIER_KEY_CODES[2]){ + iet1=2; + }else if( key.keyval == MODIFIER_KEY_CODES[3]){ + iet1=3; + } + + for(int i=0; i<6; i++){ + if( key.state == NEO_MODIFIER_MASK[i]){ + iet2=i; + break; + } + } + + iet1 = this.MODIFIER_MAP[iet1,iet2]+1; + check_modifier(iet1); + }*/ + +/* +stdout.printf("Aktuell: %i \nModifierids: %i %i %i %i\n %i %i %i %i \n %i %i %i %i %i\n\n", +key.state, Gdk.ModifierType.SHIFT_MASK, Gdk.ModifierType.LOCK_MASK, Gdk.ModifierType.CONTROL_MASK, Gdk.ModifierType.SUPER_MASK, Gdk.ModifierType.HYPER_MASK, Gdk.ModifierType.META_MASK, Gdk.ModifierType.RELEASE_MASK, Gdk.ModifierType.MODIFIER_MASK, Gdk.ModifierType.MOD1_MASK, Gdk.ModifierType.MOD2_MASK, Gdk.ModifierType.MOD3_MASK, Gdk.ModifierType.MOD4_MASK, Gdk.ModifierType.MOD5_MASK);*/ + + + return false; + } + + private void check_modifier(int iet1){ + + if(iet1 != this.ebene){ + this.ebene = iet1; + render_page (); + } + } + + public void redraw(){ + this.ebene = this.MODIFIER_MAP2[ + this.active_modifier[1], //shift + this.active_modifier[2], //neo-mod3 + this.active_modifier[3] //neo-mod4 + ] + 1; + + render_page(); + } + + + private void render_page () { + this.image.set_from_pixbuf(this.image_buffer[this.ebene]); + } + + public Gdk.Pixbuf getIcon(){ + return this.image_buffer[0]; + } + + public void external_key_press(int iet1, int modifier_mask){ + for(int iet2=0; iet2<4; iet2++){ + if(this.NEO_MODIFIER_MASK[iet2]==modifier_mask){ +//debug("(Press) e1=%i, e2=%i\n".printf(iet1,iet2)); + iet1 = this.MODIFIER_MAP[iet1,iet2]+1; + this.check_modifier(iet1); + return; + } + } + iet1 = this.MODIFIER_MAP[iet1,0]+1; + this.check_modifier(iet1); + } + + public void external_key_release(int iet1, int modifier_mask){ + for(int iet2=0; iet2<4; iet2++){ + if(this.NEO_MODIFIER_MASK[iet2]==modifier_mask){ +//debug("(Relase) e1=%i, e2=%i\n\n".printf(iet1,iet2)); + iet1 = this.MODIFIER_MAP_RELEASE[iet1,iet2]+1; + this.check_modifier(iet1); + return; + } + } + + iet1 = this.MODIFIER_MAP_RELEASE[iet1,0]+1; + this.check_modifier(iet1); + } + + /*public void updateLayer(int iet){ + if( 0{}); + manager.bind2(62, "ShiftR",1, ()=>{}); + manager.bind2(66, "Mod3L",2, ()=>{}); + manager.bind2(51, "Mod3R",2, ()=>{}); + manager.bind2(94, "Mod4",3, ()=>{}); + manager.bind2(108, "Mod4",3, ()=>{}); + manager.bind(configm.getConfig().get("show_shortcut"), ()=>{neo_win.toggle();}); + manager.bind(configm.getConfig().get("move_shortcut"), ()=>{neo_win.numkeypad_move(0);}); + + //neo_win.show_all (); + //neo_win.hide_all(); + + //move window (Fehlerquelle: config von configm, nicht neo_win. Derzeit gleiches Objekt.) + + Gtk.main (); + + manager.unbind2(50); + manager.unbind2(62); + manager.unbind2(66); + manager.unbind2(51); + manager.unbind2(94); + manager.unbind2(108); + + + return 0; + } + + } //End class NeoWindow + +} diff --git a/tray.vala b/tray.vala new file mode 100644 index 0000000..87bb347 --- /dev/null +++ b/tray.vala @@ -0,0 +1,60 @@ +using Gtk; + +namespace NeoLayoutViewer{ + + class AppStatusIcon { + public StatusIcon trayicon; + private Menu menuMain; + private NeoWindow neo_win; + + public AppStatusIcon(NeoWindow neo_win) { + this.neo_win = neo_win; + /* Create tray icon */ + //trayicon = new StatusIcon.from_stock(Stock.HOME); + //trayicon = new StatusIcon.from_file("Neo-Icon.png"); + trayicon = new StatusIcon.from_pixbuf(neo_win.get_icon()); + trayicon.set_tooltip_text ("Neo 2.0 Layout Viewer"); + trayicon.set_visible(true); + + create_menuMain(); + /* Connect popup_menu with right click */ + trayicon.popup_menu.connect(menuMain_popup); + + /* Connect main window with left click/acitvation */ + //trayicon.activate.connect(this.neo_win.show_all); + trayicon.activate.connect(()=>{this.neo_win.toggle();}); + } + + /* Create popup menu */ + public void create_menuMain() { + menuMain = new Menu(); + + var menuAbout = new ImageMenuItem.from_stock(Stock.ABOUT, null); + menuAbout.activate.connect(about_clicked); + menuMain.append(menuAbout); + + var menuQuit = new ImageMenuItem.from_stock(Stock.QUIT, null); + menuQuit.activate.connect(Gtk.main_quit); + menuMain.append(menuQuit); + menuMain.show_all(); + } + + /* Show popup menu on right button */ + private void menuMain_popup(uint button, uint time) { + menuMain.popup(null, null, null, button, time); + } + + private void about_clicked() { + var about = new AboutDialog(); + about.set_version("0.0.1"); + about.set_program_name("Neo2.0 Ebenenanzeige"); + about.set_comments("Erleichtert das Nachschlagen von Tastenkombinationen.\n\n Olaf Schulz\n schulz-AT-math.hu-berlin.de "); + about.set_copyright("GPLv?"); + about.run(); + about.hide(); + } + } + + + +} diff --git a/vapi/gtk+-2.0.vapi b/vapi/gtk+-2.0.vapi new file mode 100644 index 0000000..4e6f59c --- /dev/null +++ b/vapi/gtk+-2.0.vapi @@ -0,0 +1,8289 @@ +/* gtk+-2.0.vapi generated by vapigen, do not modify. */ + +[CCode (cprefix = "Gtk", lower_case_cprefix = "gtk_", gir_namespace = "Gtk", gir_version = "2.0")] +namespace Gtk { + [CCode (cprefix = "GtkStock", lower_case_cprefix = "gtk_stock_")] + namespace Stock { + [CCode (cheader_filename = "gtk/gtk.h")] + public const string ABOUT; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string ADD; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string APPLY; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string BOLD; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string CANCEL; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string CAPS_LOCK_WARNING; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string CDROM; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string CLEAR; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string CLOSE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string COLOR_PICKER; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string CONNECT; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string CONVERT; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string COPY; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string CUT; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string DELETE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string DIALOG_AUTHENTICATION; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string DIALOG_ERROR; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string DIALOG_INFO; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string DIALOG_QUESTION; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string DIALOG_WARNING; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string DIRECTORY; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string DISCARD; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string DISCONNECT; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string DND; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string DND_MULTIPLE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string EDIT; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string EXECUTE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string FILE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string FIND; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string FIND_AND_REPLACE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string FLOPPY; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string FULLSCREEN; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string GOTO_BOTTOM; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string GOTO_FIRST; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string GOTO_LAST; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string GOTO_TOP; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string GO_BACK; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string GO_DOWN; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string GO_FORWARD; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string GO_UP; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string HARDDISK; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string HELP; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string HOME; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string INDENT; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string INDEX; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string INFO; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string ITALIC; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string JUMP_TO; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string JUSTIFY_CENTER; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string JUSTIFY_FILL; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string JUSTIFY_LEFT; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string JUSTIFY_RIGHT; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string LEAVE_FULLSCREEN; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string MEDIA_FORWARD; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string MEDIA_NEXT; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string MEDIA_PAUSE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string MEDIA_PLAY; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string MEDIA_PREVIOUS; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string MEDIA_RECORD; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string MEDIA_REWIND; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string MEDIA_STOP; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string MISSING_IMAGE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string NETWORK; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string NEW; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string NO; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string OK; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string OPEN; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string ORIENTATION_LANDSCAPE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string ORIENTATION_PORTRAIT; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string ORIENTATION_REVERSE_LANDSCAPE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string ORIENTATION_REVERSE_PORTRAIT; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PAGE_SETUP; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PASTE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PREFERENCES; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_ERROR; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_PAUSED; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_PREVIEW; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_REPORT; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_WARNING; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PROPERTIES; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string QUIT; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string REDO; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string REFRESH; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string REMOVE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string REVERT_TO_SAVED; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string SAVE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string SAVE_AS; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string SELECT_ALL; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string SELECT_COLOR; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string SELECT_FONT; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string SORT_ASCENDING; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string SORT_DESCENDING; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string SPELL_CHECK; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOP; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STRIKETHROUGH; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string UNDELETE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string UNDERLINE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string UNDO; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string UNINDENT; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string YES; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string ZOOM_100; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string ZOOM_FIT; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string ZOOM_IN; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string ZOOM_OUT; + [CCode (cheader_filename = "gtk/gtk.h")] + public static void add (Gtk.StockItem[] items); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void add_static (Gtk.StockItem[] items); + [CCode (cheader_filename = "gtk/gtk.h")] + public static GLib.SList list_ids (); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool lookup (string stock_id, out Gtk.StockItem item); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class AboutDialog : Gtk.Dialog, Atk.Implementor, Gtk.Buildable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public AboutDialog (); + public unowned string get_artists (); + public unowned string get_authors (); + public unowned string get_comments (); + public unowned string get_copyright (); + public unowned string get_documenters (); + public unowned string get_license (); + public unowned Gdk.Pixbuf get_logo (); + public unowned string get_logo_icon_name (); + public unowned string get_program_name (); + public unowned string get_translator_credits (); + public unowned string get_version (); + public unowned string get_website (); + public unowned string get_website_label (); + public bool get_wrap_license (); + public void set_artists ([CCode (array_length = false)] string[] artists); + public void set_authors ([CCode (array_length = false)] string[] authors); + public void set_comments (string comments); + public void set_copyright (string copyright); + public void set_documenters ([CCode (array_length = false)] string[] documenters); + public static void set_email_hook (owned Gtk.AboutDialogActivateLinkFunc func); + public void set_license (string license); + public void set_logo (Gdk.Pixbuf logo); + public void set_logo_icon_name (string icon_name); + public void set_program_name (string name); + public void set_translator_credits (string translator_credits); + public static void set_url_hook (owned Gtk.AboutDialogActivateLinkFunc func); + public void set_version (string version); + public void set_website (string website); + public void set_website_label (string website_label); + public void set_wrap_license (bool wrap_license); + [CCode (array_length = false, array_null_terminated = true)] + public string[] artists { get; set; } + [CCode (array_length = false, array_null_terminated = true)] + public string[] authors { get; set; } + public string comments { get; set; } + public string copyright { get; set; } + [CCode (array_length = false, array_null_terminated = true)] + public string[] documenters { get; set; } + public string license { get; set; } + public Gdk.Pixbuf logo { get; set; } + public string logo_icon_name { get; set; } + public string program_name { get; set; } + public string translator_credits { get; set; } + public string version { get; set; } + public string website { get; set; } + public string website_label { get; set; } + public bool wrap_license { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class AccelGroup : GLib.Object { + public weak GLib.SList acceleratables; + public uint lock_count; + public uint n_accels; + [CCode (has_construct_function = false)] + public AccelGroup (); + public bool activate (GLib.Quark accel_quark, GLib.Object acceleratable, uint accel_key, Gdk.ModifierType accel_mods); + public void connect (uint accel_key, Gdk.ModifierType accel_mods, Gtk.AccelFlags accel_flags, [CCode (type = "GClosure*")] owned Gtk.AccelGroupActivate closure); + public void connect_by_path (string accel_path, [CCode (type = "GClosure*")] owned Gtk.AccelGroupActivate closure); + public bool disconnect (GLib.Closure closure); + public bool disconnect_key (uint accel_key, Gdk.ModifierType accel_mods); + public Gtk.AccelKey* find (Gtk.AccelGroupFindFunc find_func); + public static unowned Gtk.AccelGroup from_accel_closure (GLib.Closure closure); + public bool get_is_locked (); + public Gdk.ModifierType get_modifier_mask (); + public void @lock (); + public unowned Gtk.AccelGroupEntry query (uint accel_key, Gdk.ModifierType accel_mods, uint n_entries); + public void unlock (); + public bool is_locked { get; } + public Gdk.ModifierType modifier_mask { get; } + public virtual signal bool accel_activate (GLib.Object p0, uint p1, Gdk.ModifierType p2); + public virtual signal void accel_changed (uint keyval, Gdk.ModifierType modifier, GLib.Closure accel_closure); + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class AccelGroupEntry { + public GLib.Quark accel_path_quark; + public weak GLib.Closure closure; + public Gtk.AccelKey key; + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class AccelLabel : Gtk.Label, Atk.Implementor, Gtk.Buildable { + public weak Gtk.AccelGroup accel_group; + public uint accel_padding; + public weak string accel_string; + public uint16 accel_string_width; + public uint gtk_reserved; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public AccelLabel (string str); + public unowned Gtk.Widget get_accel_widget (); + public uint get_accel_width (); + public bool refetch (); + public void set_accel_closure ([CCode (type = "GClosure*")] owned Gtk.AccelGroupActivate accel_closure); + public void set_accel_widget (Gtk.Widget accel_widget); + [NoAccessorMethod] + public GLib.Closure accel_closure { owned get; set; } + public Gtk.Widget accel_widget { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class AccelMap : GLib.Object { + [CCode (has_construct_function = false)] + protected AccelMap (); + public static void add_entry (string accel_path, uint accel_key, Gdk.ModifierType accel_mods); + public static void add_filter (string filter_pattern); + public static bool change_entry (string accel_path, uint accel_key, Gdk.ModifierType accel_mods, bool replace); + public static void @foreach (void* data, Gtk.AccelMapForeach foreach_func); + public static void foreach_unfiltered (void* data, Gtk.AccelMapForeach foreach_func); + public static unowned Gtk.AccelMap @get (); + public static void load (string file_name); + public static void load_fd (int fd); + public static void load_scanner (GLib.Scanner scanner); + public static void lock_path (string accel_path); + public static bool lookup_entry (string accel_path, out Gtk.AccelKey key); + public static void save (string file_name); + public static void save_fd (int fd); + public static void unlock_path (string accel_path); + public virtual signal void changed (string p0, uint p1, Gdk.ModifierType p2); + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class AccelMapClass { + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Accessible : Atk.Object { + public weak Gtk.Widget widget; + [CCode (has_construct_function = false)] + protected Accessible (); + public virtual void connect_widget_destroyed (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Action : GLib.Object, Gtk.Buildable { + [CCode (has_construct_function = false)] + public Action (string name, string? label, string? tooltip, string? stock_id); + public void block_activate (); + public void connect_accelerator (); + [NoWrapper] + public virtual void connect_proxy (Gtk.Widget proxy); + public unowned Gtk.Widget create_icon (Gtk.IconSize icon_size); + public virtual unowned Gtk.Widget create_menu (); + public virtual unowned Gtk.Widget create_menu_item (); + public virtual unowned Gtk.Widget create_tool_item (); + public void disconnect_accelerator (); + [NoWrapper] + public virtual void disconnect_proxy (Gtk.Widget proxy); + public unowned GLib.Closure get_accel_closure (); + public unowned string get_accel_path (); + public bool get_always_show_image (); + public unowned GLib.Icon get_gicon (); + public unowned string get_icon_name (); + public bool get_is_important (); + public unowned string get_label (); + public unowned GLib.SList get_proxies (); + public bool get_sensitive (); + public unowned string get_short_label (); + public unowned string get_stock_id (); + public unowned string get_tooltip (); + public bool get_visible (); + public bool get_visible_horizontal (); + public bool get_visible_vertical (); + public bool is_sensitive (); + public bool is_visible (); + public void set_accel_group (Gtk.AccelGroup accel_group); + public void set_accel_path (string accel_path); + public void set_always_show_image (bool always_show); + public void set_gicon (GLib.Icon icon); + public void set_icon_name (string icon_name); + public void set_is_important (bool is_important); + public void set_label (string label); + public void set_sensitive (bool sensitive); + public void set_short_label (string short_label); + public void set_stock_id (string stock_id); + public void set_tooltip (string tooltip); + public void set_visible (bool visible); + public void set_visible_horizontal (bool visible_horizontal); + public void set_visible_vertical (bool visible_vertical); + public void unblock_activate (); + [NoAccessorMethod] + public Gtk.ActionGroup action_group { owned get; set; } + public bool always_show_image { get; set construct; } + public GLib.Icon gicon { get; set; } + [NoAccessorMethod] + public bool hide_if_empty { get; set; } + public string icon_name { get; set; } + public bool is_important { get; set; } + public string label { get; set; } + public string name { get; construct; } + public bool sensitive { get; set; } + public string short_label { get; set; } + public string stock_id { get; set; } + public string tooltip { get; set; } + public bool visible { get; set; } + public bool visible_horizontal { get; set; } + [NoAccessorMethod] + public bool visible_overflown { get; set; } + public bool visible_vertical { get; set; } + [HasEmitter] + public virtual signal void activate (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class ActionGroup : GLib.Object, Gtk.Buildable { + [CCode (has_construct_function = false)] + public ActionGroup (string name); + public void add_action (Gtk.Action action); + public void add_action_with_accel (Gtk.Action action, string? accelerator); + public void add_actions (Gtk.ActionEntry[] entries, void* user_data); + public void add_actions_full (Gtk.ActionEntry[] entries, void* user_data, GLib.DestroyNotify? destroy); + public void add_radio_actions (Gtk.RadioActionEntry[] entries, int value, [CCode (type = "GCallback")] Gtk.RadioActionCallback on_change); + public void add_radio_actions_full (Gtk.RadioActionEntry[] entries, int value, [CCode (type = "GCallback")] Gtk.RadioActionCallback on_change, GLib.DestroyNotify? destroy); + public void add_toggle_actions (Gtk.ToggleActionEntry[] entries, void* user_data); + public void add_toggle_actions_full (Gtk.ToggleActionEntry[] entries, void* user_data, GLib.DestroyNotify? destroy); + public virtual unowned Gtk.Action get_action (string action_name); + public bool get_sensitive (); + public bool get_visible (); + public GLib.List list_actions (); + public void remove_action (Gtk.Action action); + public void set_sensitive (bool sensitive); + public void set_translate_func (owned Gtk.TranslateFunc func); + public void set_translation_domain (string domain); + public void set_visible (bool visible); + public unowned string translate_string (string str); + public string name { get; construct; } + public bool sensitive { get; set; } + public bool visible { get; set; } + public virtual signal void connect_proxy (Gtk.Action p0, Gtk.Widget p1); + public virtual signal void disconnect_proxy (Gtk.Action p0, Gtk.Widget p1); + public virtual signal void post_activate (Gtk.Action p0); + public virtual signal void pre_activate (Gtk.Action p0); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Adjustment : Gtk.Object { + [CCode (type = "GtkObject*", has_construct_function = false)] + public Adjustment (double value, double lower, double upper, double step_increment, double page_increment, double page_size); + public void clamp_page (double lower, double upper); + public void configure (double value, double lower, double upper, double step_increment, double page_increment, double page_size); + public double get_lower (); + public double get_page_increment (); + public double get_page_size (); + public double get_step_increment (); + public double get_upper (); + public double get_value (); + public void set_lower (double lower); + public void set_page_increment (double page_increment); + public void set_page_size (double page_size); + public void set_step_increment (double step_increment); + public void set_upper (double upper); + public void set_value (double value); + public double lower { get; set; } + public double page_increment { get; set; } + public double page_size { get; set; } + public double step_increment { get; set; } + public double upper { get; set; } + public double value { get; set; } + [HasEmitter] + public virtual signal void changed (); + [HasEmitter] + public virtual signal void value_changed (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Alignment : Gtk.Bin, Atk.Implementor, Gtk.Buildable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Alignment (float xalign, float yalign, float xscale, float yscale); + public void get_padding (out uint padding_top, out uint padding_bottom, out uint padding_left, out uint padding_right); + public void @set (float xalign, float yalign, float xscale, float yscale); + public void set_padding (uint padding_top, uint padding_bottom, uint padding_left, uint padding_right); + [NoAccessorMethod] + public uint bottom_padding { get; set; } + [NoAccessorMethod] + public uint left_padding { get; set; } + [NoAccessorMethod] + public uint right_padding { get; set; } + [NoAccessorMethod] + public uint top_padding { get; set; } + [NoAccessorMethod] + public float xalign { get; set; } + [NoAccessorMethod] + public float xscale { get; set; } + [NoAccessorMethod] + public float yalign { get; set; } + [NoAccessorMethod] + public float yscale { get; set; } + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class Arg { + public weak string name; + public GLib.Type type; + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Arrow : Gtk.Misc, Atk.Implementor, Gtk.Buildable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Arrow (Gtk.ArrowType arrow_type, Gtk.ShadowType shadow_type); + public void @set (Gtk.ArrowType arrow_type, Gtk.ShadowType shadow_type); + [NoAccessorMethod] + public Gtk.ArrowType arrow_type { get; set; } + [NoAccessorMethod] + public Gtk.ShadowType shadow_type { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class AspectFrame : Gtk.Frame, Atk.Implementor, Gtk.Buildable { + public Gtk.Allocation center_allocation; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public AspectFrame (string label, float xalign, float yalign, float ratio, bool obey_child); + public void @set (float xalign, float yalign, float ratio, bool obey_child); + [NoAccessorMethod] + public bool obey_child { get; set; } + [NoAccessorMethod] + public float ratio { get; set; } + [NoAccessorMethod] + public float xalign { get; set; } + [NoAccessorMethod] + public float yalign { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Assistant : Gtk.Window, Atk.Implementor, Gtk.Buildable { + public weak Gtk.Widget back; + public weak Gtk.Widget forward; + public weak Gtk.Widget last; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Assistant (); + public void add_action_widget (Gtk.Widget child); + public int append_page (Gtk.Widget page); + public int get_current_page (); + public int get_n_pages (); + public unowned Gtk.Widget get_nth_page (int page_num); + public bool get_page_complete (Gtk.Widget page); + public unowned Gdk.Pixbuf get_page_header_image (Gtk.Widget page); + public unowned Gdk.Pixbuf get_page_side_image (Gtk.Widget page); + public unowned string get_page_title (Gtk.Widget page); + public Gtk.AssistantPageType get_page_type (Gtk.Widget page); + public int insert_page (Gtk.Widget page, int position); + public int prepend_page (Gtk.Widget page); + public void remove_action_widget (Gtk.Widget child); + public void set_current_page (int page_num); + public void set_forward_page_func (owned Gtk.AssistantPageFunc page_func); + public void set_page_complete (Gtk.Widget page, bool complete); + public void set_page_header_image (Gtk.Widget page, Gdk.Pixbuf pixbuf); + public void set_page_side_image (Gtk.Widget page, Gdk.Pixbuf pixbuf); + public void set_page_title (Gtk.Widget page, string title); + public void set_page_type (Gtk.Widget page, Gtk.AssistantPageType type); + public void update_buttons_state (); + public virtual signal void apply (); + public virtual signal void cancel (); + public virtual signal void close (); + public virtual signal void prepare (Gtk.Widget page); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Bin : Gtk.Container, Atk.Implementor, Gtk.Buildable { + public weak Gtk.Widget child; + [CCode (has_construct_function = false)] + protected Bin (); + public unowned Gtk.Widget get_child (); + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class BindingArg { + public GLib.Type arg_type; + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class BindingEntry { + public weak Gtk.BindingSet binding_set; + public uint destroyed; + public weak Gtk.BindingEntry hash_next; + public uint in_emission; + public uint keyval; + public uint marks_unbound; + public Gdk.ModifierType modifiers; + public weak Gtk.BindingEntry set_next; + public weak Gtk.BindingSignal signals; + public static void add_signal (Gtk.BindingSet binding_set, uint keyval, Gdk.ModifierType modifiers, string signal_name, uint n_args); + public static void add_signall (Gtk.BindingSet binding_set, uint keyval, Gdk.ModifierType modifiers, string signal_name, GLib.SList binding_args); + public static void remove (Gtk.BindingSet binding_set, uint keyval, Gdk.ModifierType modifiers); + public static void skip (Gtk.BindingSet binding_set, uint keyval, Gdk.ModifierType modifiers); + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class BindingSet { + public weak Gtk.BindingEntry current; + public weak Gtk.BindingEntry entries; + public uint parsed; + public int priority; + public weak string set_name; + [CCode (has_construct_function = false)] + public BindingSet (string set_name); + public bool activate (uint keyval, Gdk.ModifierType modifiers, Gtk.Object object); + public void add_path (Gtk.PathType path_type, string path_pattern, Gtk.PathPriorityType priority); + public static unowned Gtk.BindingSet by_class (void* object_class); + public static unowned Gtk.BindingSet find (string set_name); + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class BindingSignal { + public weak Gtk.BindingArg args; + public uint n_args; + public weak Gtk.BindingSignal next; + public weak string signal_name; + } + [Compact] + [CCode (copy_function = "gtk_border_copy", type_id = "GTK_TYPE_BORDER", cheader_filename = "gtk/gtk.h")] + public class Border { + public int bottom; + public int left; + public int right; + public int top; + [CCode (has_construct_function = false)] + public Border (); + public Gtk.Border copy (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Box : Gtk.Container, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + public weak GLib.List children; + [CCode (has_construct_function = false)] + protected Box (); + public bool get_homogeneous (); + public int get_spacing (); + public void pack_end (Gtk.Widget child, bool expand = true, bool fill = true, uint padding = 0); + public void pack_start (Gtk.Widget child, bool expand = true, bool fill = true, uint padding = 0); + public void query_child_packing (Gtk.Widget child, out bool expand, out bool fill, out uint padding, out Gtk.PackType pack_type); + public void reorder_child (Gtk.Widget child, int position); + public void set_child_packing (Gtk.Widget child, bool expand, bool fill, uint padding, Gtk.PackType pack_type); + public void set_homogeneous (bool homogeneous); + public void set_spacing (int spacing); + public bool homogeneous { get; set; } + public int spacing { get; set; } + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class BoxChild { + public uint expand; + public uint fill; + public uint is_secondary; + public uint pack; + public uint16 padding; + public weak Gtk.Widget widget; + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Builder : GLib.Object { + [CCode (has_construct_function = false)] + public Builder (); + public uint add_from_file (string filename) throws GLib.Error; + public uint add_from_string (string buffer, size_t length) throws GLib.Error; + public uint add_objects_from_file (string filename, [CCode (array_length = false)] string[] object_ids) throws GLib.Error; + public uint add_objects_from_string (string buffer, size_t length, [CCode (array_length = false)] string[] object_ids) throws GLib.Error; + public void connect_signals (void* user_data); + public void connect_signals_full (Gtk.BuilderConnectFunc func); + public static GLib.Quark error_quark (); + public unowned GLib.Object get_object (string name); + public GLib.SList get_objects (); + public unowned string get_translation_domain (); + public virtual GLib.Type get_type_from_name (string type_name); + public void set_translation_domain (string domain); + public bool value_from_string (GLib.ParamSpec pspec, string str, GLib.Value value) throws GLib.Error; + public bool value_from_string_type (GLib.Type type, string str, GLib.Value value) throws GLib.Error; + public string translation_domain { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Button : Gtk.Bin, Atk.Implementor, Gtk.Buildable, Gtk.Activatable { + public uint activate_timeout; + public uint button_down; + public uint constructed; + public uint depress_on_activate; + public uint depressed; + public weak Gdk.Window event_window; + public uint in_button; + public weak string label_text; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Button (); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Button.from_stock (string stock_id); + public void get_alignment (out float xalign, out float yalign); + public bool get_focus_on_click (); + public unowned Gtk.Widget get_image (); + public Gtk.PositionType get_image_position (); + public unowned string get_label (); + public Gtk.ReliefStyle get_relief (); + public bool get_use_stock (); + public bool get_use_underline (); + public void set_alignment (float xalign, float yalign); + public void set_focus_on_click (bool focus_on_click); + public void set_image (Gtk.Widget image); + public void set_image_position (Gtk.PositionType position); + public void set_label (string label); + public void set_relief (Gtk.ReliefStyle newstyle); + public void set_use_stock (bool use_stock); + public void set_use_underline (bool use_underline); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Button.with_label (string label); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Button.with_mnemonic (string label); + public bool focus_on_click { get; set; } + public Gtk.Widget image { get; set; } + public Gtk.PositionType image_position { get; set; } + public string label { get; set construct; } + public Gtk.ReliefStyle relief { get; set; } + public bool use_stock { get; set construct; } + public bool use_underline { get; set construct; } + [NoAccessorMethod] + public float xalign { get; set; } + [NoAccessorMethod] + public float yalign { get; set; } + public virtual signal void activate (); + [HasEmitter] + public virtual signal void clicked (); + [HasEmitter] + public virtual signal void enter (); + [HasEmitter] + public virtual signal void leave (); + [HasEmitter] + public virtual signal void pressed (); + [HasEmitter] + public virtual signal void released (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class ButtonBox : Gtk.Box, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + public int child_ipad_x; + public int child_ipad_y; + public int child_min_height; + public int child_min_width; + [CCode (has_construct_function = false)] + protected ButtonBox (); + public bool get_child_secondary (Gtk.Widget child); + public Gtk.ButtonBoxStyle get_layout (); + public void set_child_secondary (Gtk.Widget child, bool is_secondary); + public void set_layout (Gtk.ButtonBoxStyle layout_style); + [NoAccessorMethod] + public Gtk.ButtonBoxStyle layout_style { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Calendar : Gtk.Widget, Atk.Implementor, Gtk.Buildable { + [CCode (array_length = false)] + public weak int[] day_month; + public Gtk.CalendarDisplayOptions display_flags; + public int focus_col; + public int focus_row; + public weak Gdk.GC gc; + [CCode (array_length = false)] + public weak char[] grow_space; + public weak Gtk.Style header_style; + public int highlight_col; + public int highlight_row; + public weak Gtk.Style label_style; + [CCode (array_length = false)] + public weak int[] marked_date; + [CCode (array_length = false)] + public weak Gdk.Color[] marked_date_color; + public int num_marked_dates; + public int selected_day; + public weak Gdk.GC xor_gc; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Calendar (); + public void clear_marks (); + public void get_date (out uint year, out uint month, out uint day); + public int get_detail_height_rows (); + public int get_detail_width_chars (); + public Gtk.CalendarDisplayOptions get_display_options (); + public bool mark_day (uint day); + public void select_day (uint day); + public bool select_month (uint month, uint year); + public void set_detail_func (owned Gtk.CalendarDetailFunc func); + public void set_detail_height_rows (int rows); + public void set_detail_width_chars (int chars); + public void set_display_options (Gtk.CalendarDisplayOptions flags); + public bool unmark_day (uint day); + [NoAccessorMethod] + public int day { get; set; } + public int detail_height_rows { get; set; } + public int detail_width_chars { get; set; } + [NoAccessorMethod] + public int month { get; set; } + [NoAccessorMethod] + public bool no_month_change { get; set; } + [NoAccessorMethod] + public bool show_day_names { get; set; } + [NoAccessorMethod] + public bool show_details { get; set; } + [NoAccessorMethod] + public bool show_heading { get; set; } + [NoAccessorMethod] + public bool show_week_numbers { get; set; } + [NoAccessorMethod] + public int year { get; set; } + public virtual signal void day_selected (); + public virtual signal void day_selected_double_click (); + public virtual signal void month_changed (); + public virtual signal void next_month (); + public virtual signal void next_year (); + public virtual signal void prev_month (); + public virtual signal void prev_year (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public abstract class CellRenderer : Gtk.Object { + [CCode (has_construct_function = false)] + protected CellRenderer (); + public virtual bool activate (Gdk.Event event, Gtk.Widget widget, string path, Gdk.Rectangle background_area, Gdk.Rectangle cell_area, Gtk.CellRendererState flags); + public void get_alignment (out float xalign, out float yalign); + public void get_fixed_size (out int width, out int height); + public void get_padding (out int xpad, out int ypad); + public bool get_sensitive (); + public abstract void get_size (Gtk.Widget widget, Gdk.Rectangle? cell_area, out int x_offset, out int y_offset, out int width, out int height); + public bool get_visible (); + public abstract void render (Gdk.Window window, Gtk.Widget widget, Gdk.Rectangle background_area, Gdk.Rectangle cell_area, Gdk.Rectangle expose_area, Gtk.CellRendererState flags); + public void set_alignment (float xalign, float yalign); + public void set_fixed_size (int width, int height); + public void set_padding (int xpad, int ypad); + public void set_sensitive (bool sensitive); + public void set_visible (bool visible); + public virtual unowned Gtk.CellEditable start_editing (Gdk.Event event, Gtk.Widget widget, string path, Gdk.Rectangle background_area, Gdk.Rectangle cell_area, Gtk.CellRendererState flags); + public void stop_editing (bool canceled); + [NoAccessorMethod] + public string cell_background { set; } + [NoAccessorMethod] + public Gdk.Color cell_background_gdk { get; set; } + [NoAccessorMethod] + public bool cell_background_set { get; set; } + [NoAccessorMethod] + public bool editing { get; } + [NoAccessorMethod] + public int height { get; set; } + [NoAccessorMethod] + public bool is_expanded { get; set; } + [NoAccessorMethod] + public bool is_expander { get; set; } + [NoAccessorMethod] + public Gtk.CellRendererMode mode { get; set; } + public bool sensitive { get; set; } + public bool visible { get; set; } + [NoAccessorMethod] + public int width { get; set; } + [NoAccessorMethod] + public float xalign { get; set; } + [NoAccessorMethod] + public uint xpad { get; set; } + [NoAccessorMethod] + public float yalign { get; set; } + [NoAccessorMethod] + public uint ypad { get; set; } + [HasEmitter] + public virtual signal void editing_canceled (); + public virtual signal void editing_started (Gtk.CellEditable editable, string path); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class CellRendererAccel : Gtk.CellRendererText { + public weak Gtk.Widget edit_widget; + public weak Gtk.Widget grab_widget; + public weak Gtk.Widget sizing_label; + [CCode (type = "GtkCellRenderer*", has_construct_function = false)] + public CellRendererAccel (); + [NoAccessorMethod] + public uint accel_key { get; set; } + [NoAccessorMethod] + public Gtk.CellRendererAccelMode accel_mode { get; set; } + [NoAccessorMethod] + public Gdk.ModifierType accel_mods { get; set; } + [NoAccessorMethod] + public uint keycode { get; set; } + public virtual signal void accel_cleared (string path_string); + public virtual signal void accel_edited (string path_string, uint accel_key, Gdk.ModifierType accel_mods, uint hardware_keycode); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class CellRendererCombo : Gtk.CellRendererText { + public uint focus_out_id; + [CCode (type = "GtkCellRenderer*", has_construct_function = false)] + public CellRendererCombo (); + [NoAccessorMethod] + public bool has_entry { get; set; } + [NoAccessorMethod] + public Gtk.TreeModel model { owned get; set; } + [NoAccessorMethod] + public int text_column { get; set; } + public virtual signal void changed (string p0, Gtk.TreeIter p1); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class CellRendererPixbuf : Gtk.CellRenderer { + [CCode (type = "GtkCellRenderer*", has_construct_function = false)] + public CellRendererPixbuf (); + [NoAccessorMethod] + public bool follow_state { get; set; } + [NoAccessorMethod] + public GLib.Icon gicon { owned get; set; } + [NoAccessorMethod] + public string icon_name { owned get; set; } + [NoAccessorMethod] + public Gdk.Pixbuf pixbuf { owned get; set; } + [NoAccessorMethod] + public Gdk.Pixbuf pixbuf_expander_closed { owned get; set; } + [NoAccessorMethod] + public Gdk.Pixbuf pixbuf_expander_open { owned get; set; } + [NoAccessorMethod] + public string stock_detail { owned get; set; } + [NoAccessorMethod] + public string stock_id { owned get; set; } + [NoAccessorMethod] + public uint stock_size { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class CellRendererProgress : Gtk.CellRenderer { + [CCode (type = "GtkCellRenderer*", has_construct_function = false)] + public CellRendererProgress (); + [NoAccessorMethod] + public Gtk.ProgressBarOrientation orientation { get; set; } + [NoAccessorMethod] + public int pulse { get; set; } + [NoAccessorMethod] + public string text { owned get; set; } + [NoAccessorMethod] + public float text_xalign { get; set; } + [NoAccessorMethod] + public float text_yalign { get; set; } + [NoAccessorMethod] + public int value { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class CellRendererSpin : Gtk.CellRendererText { + [CCode (type = "GtkCellRenderer*", has_construct_function = false)] + public CellRendererSpin (); + [NoAccessorMethod] + public Gtk.Adjustment adjustment { owned get; set; } + [NoAccessorMethod] + public double climb_rate { get; set; } + [NoAccessorMethod] + public uint digits { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class CellRendererSpinner : Gtk.CellRenderer { + [CCode (type = "GtkCellRenderer*", has_construct_function = false)] + public CellRendererSpinner (); + [NoAccessorMethod] + public bool active { get; set; } + [NoAccessorMethod] + public uint pulse { get; set; } + [NoAccessorMethod] + public Gtk.IconSize size { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class CellRendererText : Gtk.CellRenderer { + public uint calc_fixed_height; + public weak Pango.AttrList extra_attrs; + public int fixed_height_rows; + public double font_scale; + public Pango.Underline underline_style; + [CCode (type = "GtkCellRenderer*", has_construct_function = false)] + public CellRendererText (); + public void set_fixed_height_from_font (int number_of_rows); + [NoAccessorMethod] + public bool align_set { get; set; } + [NoAccessorMethod] + public Pango.Alignment alignment { get; set; } + [NoAccessorMethod] + public Pango.AttrList attributes { owned get; set; } + [NoAccessorMethod] + public string background { set; } + [NoAccessorMethod] + public Gdk.Color background_gdk { get; set; } + [NoAccessorMethod] + public bool background_set { get; set; } + [NoAccessorMethod] + public bool editable { get; set; } + [NoAccessorMethod] + public bool editable_set { get; set; } + [NoAccessorMethod] + public Pango.EllipsizeMode ellipsize { get; set; } + [NoAccessorMethod] + public bool ellipsize_set { get; set; } + [NoAccessorMethod] + public string family { owned get; set; } + [NoAccessorMethod] + public bool family_set { get; set; } + [NoAccessorMethod] + public string font { owned get; set; } + [NoAccessorMethod] + public Pango.FontDescription font_desc { owned get; set; } + [NoAccessorMethod] + public string foreground { set; } + [NoAccessorMethod] + public Gdk.Color foreground_gdk { get; set; } + [NoAccessorMethod] + public bool foreground_set { get; set; } + [NoAccessorMethod] + public string language { owned get; set; } + [NoAccessorMethod] + public bool language_set { get; set; } + [NoAccessorMethod] + public string markup { set; } + [NoAccessorMethod] + public int rise { get; set; } + [NoAccessorMethod] + public bool rise_set { get; set; } + [NoAccessorMethod] + public double scale { get; set; } + [NoAccessorMethod] + public bool scale_set { get; set; } + [NoAccessorMethod] + public bool single_paragraph_mode { get; set; } + [NoAccessorMethod] + public int size { get; set; } + [NoAccessorMethod] + public double size_points { get; set; } + [NoAccessorMethod] + public bool size_set { get; set; } + [NoAccessorMethod] + public Pango.Stretch stretch { get; set; } + [NoAccessorMethod] + public bool stretch_set { get; set; } + [NoAccessorMethod] + public bool strikethrough { get; set; } + [NoAccessorMethod] + public bool strikethrough_set { get; set; } + [NoAccessorMethod] + public Pango.Style style { get; set; } + [NoAccessorMethod] + public bool style_set { get; set; } + [NoAccessorMethod] + public string text { owned get; set; } + [NoAccessorMethod] + public Pango.Underline underline { get; set; } + [NoAccessorMethod] + public bool underline_set { get; set; } + [NoAccessorMethod] + public Pango.Variant variant { get; set; } + [NoAccessorMethod] + public bool variant_set { get; set; } + [NoAccessorMethod] + public int weight { get; set; } + [NoAccessorMethod] + public bool weight_set { get; set; } + [NoAccessorMethod] + public int width_chars { get; set; } + [NoAccessorMethod] + public Pango.WrapMode wrap_mode { get; set; } + [NoAccessorMethod] + public int wrap_width { get; set; } + public virtual signal void edited (string path, string new_text); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class CellRendererToggle : Gtk.CellRenderer { + [CCode (type = "GtkCellRenderer*", has_construct_function = false)] + public CellRendererToggle (); + public bool get_activatable (); + public bool get_active (); + public bool get_radio (); + public void set_activatable (bool setting); + public void set_active (bool setting); + public void set_radio (bool radio); + public bool activatable { get; set; } + public bool active { get; set; } + [NoAccessorMethod] + public bool inconsistent { get; set; } + [NoAccessorMethod] + public int indicator_size { get; set; } + public bool radio { get; set; } + public virtual signal void toggled (string path); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class CellView : Gtk.Widget, Atk.Implementor, Gtk.Buildable, Gtk.CellLayout { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public CellView (); + public unowned Gtk.TreePath get_displayed_row (); + public unowned Gtk.TreeModel get_model (); + public bool get_size_of_row (Gtk.TreePath path, out Gtk.Requisition requisition); + public void set_background_color (Gdk.Color color); + public void set_displayed_row (Gtk.TreePath path); + public void set_model (Gtk.TreeModel? model); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public CellView.with_markup (string markup); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public CellView.with_pixbuf (Gdk.Pixbuf pixbuf); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public CellView.with_text (string text); + [NoAccessorMethod] + public string background { set; } + [NoAccessorMethod] + public Gdk.Color background_gdk { get; set; } + [NoAccessorMethod] + public bool background_set { get; set; } + public Gtk.TreeModel model { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class CheckButton : Gtk.ToggleButton, Atk.Implementor, Gtk.Buildable, Gtk.Activatable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public CheckButton (); + [NoWrapper] + public virtual void draw_indicator (Gdk.Rectangle area); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public CheckButton.with_label (string label); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public CheckButton.with_mnemonic (string label); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class CheckMenuItem : Gtk.MenuItem, Atk.Implementor, Gtk.Buildable, Gtk.Activatable { + public uint always_show_toggle; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public CheckMenuItem (); + [NoWrapper] + public virtual void draw_indicator (Gdk.Rectangle area); + public bool get_active (); + public bool get_draw_as_radio (); + public bool get_inconsistent (); + public void set_active (bool is_active); + public void set_draw_as_radio (bool draw_as_radio); + public void set_inconsistent (bool setting); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public CheckMenuItem.with_label (string label); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public CheckMenuItem.with_mnemonic (string label); + public bool active { get; set; } + public bool draw_as_radio { get; set; } + public bool inconsistent { get; set; } + [HasEmitter] + public virtual signal void toggled (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Clipboard : GLib.Object { + [CCode (has_construct_function = false)] + protected Clipboard (); + public void clear (); + public static unowned Gtk.Clipboard @get (Gdk.Atom selection); + public unowned Gdk.Display get_display (); + public static unowned Gtk.Clipboard get_for_display (Gdk.Display display, Gdk.Atom selection); + public unowned GLib.Object get_owner (); + public void request_contents (Gdk.Atom target, Gtk.ClipboardReceivedFunc callback); + public void request_image (Gtk.ClipboardImageReceivedFunc callback); + public void request_rich_text (Gtk.TextBuffer buffer, Gtk.ClipboardRichTextReceivedFunc callback); + public void request_targets (Gtk.ClipboardTargetsReceivedFunc callback); + public void request_text (Gtk.ClipboardTextReceivedFunc callback); + public void request_uris (Gtk.ClipboardURIReceivedFunc callback); + public void set_can_store (Gtk.TargetEntry[] targets); + public void set_image (Gdk.Pixbuf pixbuf); + public void set_text (string text, int len); + public bool set_with_data (Gtk.TargetEntry[] targets, Gtk.ClipboardGetFunc get_func, Gtk.ClipboardClearFunc clear_func); + public bool set_with_owner (Gtk.TargetEntry[] targets, Gtk.ClipboardGetFunc get_func, Gtk.ClipboardClearFunc clear_func, GLib.Object owner); + public void store (); + public Gtk.SelectionData? wait_for_contents (Gdk.Atom target); + public Gdk.Pixbuf? wait_for_image (); + [CCode (array_length_type = "gsize")] + public uint8[]? wait_for_rich_text (Gtk.TextBuffer buffer, out Gdk.Atom format); + public bool wait_for_targets (out Gdk.Atom[] targets); + public string? wait_for_text (); + [CCode (array_length = false, array_null_terminated = true)] + public string[]? wait_for_uris (); + public bool wait_is_image_available (); + public bool wait_is_rich_text_available (Gtk.TextBuffer buffer); + public bool wait_is_target_available (Gdk.Atom target); + public bool wait_is_text_available (); + public bool wait_is_uris_available (); + public virtual signal void owner_change (Gdk.Event p0); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class ColorButton : Gtk.Button, Atk.Implementor, Gtk.Buildable, Gtk.Activatable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public ColorButton (); + public uint16 get_alpha (); + public void get_color (out Gdk.Color color); + public unowned string get_title (); + public bool get_use_alpha (); + public void set_alpha (uint16 alpha); + public void set_color (Gdk.Color color); + public void set_title (string title); + public void set_use_alpha (bool use_alpha); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public ColorButton.with_color (Gdk.Color color); + public uint alpha { get; set; } + public Gdk.Color color { get; set; } + public string title { get; set; } + public bool use_alpha { get; set; } + public virtual signal void color_set (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class ColorSelection : Gtk.VBox, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public ColorSelection (); + public uint16 get_current_alpha (); + public void get_current_color (out Gdk.Color color); + public bool get_has_opacity_control (); + public bool get_has_palette (); + public uint16 get_previous_alpha (); + public void get_previous_color (out Gdk.Color color); + public bool is_adjusting (); + public static bool palette_from_string (string str, Gdk.Color[] colors); + public static unowned string palette_to_string (Gdk.Color[] colors); + public static unowned Gtk.ColorSelectionChangePaletteWithScreenFunc set_change_palette_with_screen_hook (Gtk.ColorSelectionChangePaletteWithScreenFunc func); + public void set_current_alpha (uint16 alpha); + public void set_current_color (Gdk.Color color); + public void set_has_opacity_control (bool has_opacity); + public void set_has_palette (bool has_palette); + public void set_previous_alpha (uint16 alpha); + public void set_previous_color (Gdk.Color color); + public uint current_alpha { get; set; } + public Gdk.Color current_color { get; set; } + public bool has_opacity_control { get; set; } + public bool has_palette { get; set; } + public virtual signal void color_changed (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class ColorSelectionDialog : Gtk.Dialog, Atk.Implementor, Gtk.Buildable { + public weak Gtk.Widget colorsel; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public ColorSelectionDialog (string title); + public unowned Gtk.Widget get_color_selection (); + [NoAccessorMethod] + public Gtk.Widget cancel_button { owned get; } + public Gtk.Widget color_selection { get; } + [NoAccessorMethod] + public Gtk.Widget help_button { owned get; } + [NoAccessorMethod] + public Gtk.Widget ok_button { owned get; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class ComboBox : Gtk.Bin, Atk.Implementor, Gtk.Buildable, Gtk.CellEditable, Gtk.CellLayout { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public ComboBox (); + public void append_text (string text); + public int get_active (); + public bool get_active_iter (out Gtk.TreeIter iter); + public virtual unowned string get_active_text (); + public bool get_add_tearoffs (); + public Gtk.SensitivityType get_button_sensitivity (); + public int get_column_span_column (); + public bool get_focus_on_click (); + public unowned Gtk.TreeModel get_model (); + public unowned Atk.Object get_popup_accessible (); + public unowned Gtk.TreeViewRowSeparatorFunc get_row_separator_func (); + public int get_row_span_column (); + public unowned string get_title (); + public int get_wrap_width (); + public void insert_text (int position, string text); + public void prepend_text (string text); + public void remove_text (int position); + public void set_active (int index_); + public void set_active_iter (Gtk.TreeIter iter); + public void set_add_tearoffs (bool add_tearoffs); + public void set_button_sensitivity (Gtk.SensitivityType sensitivity); + public void set_column_span_column (int column_span); + public void set_focus_on_click (bool focus_on_click); + public void set_model (Gtk.TreeModel? model); + public void set_row_separator_func (owned Gtk.TreeViewRowSeparatorFunc func); + public void set_row_span_column (int row_span); + public void set_title (string title); + public void set_wrap_width (int width); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public ComboBox.text (); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public ComboBox.with_model (Gtk.TreeModel model); + public int active { get; set; } + public bool add_tearoffs { get; set; } + public Gtk.SensitivityType button_sensitivity { get; set; } + public int column_span_column { get; set; } + public bool focus_on_click { get; set; } + [NoAccessorMethod] + public bool has_frame { get; set; } + public Gtk.TreeModel model { get; set; } + [NoAccessorMethod] + public bool popup_shown { get; } + public int row_span_column { get; set; } + [NoAccessorMethod] + public string tearoff_title { owned get; set; } + public int wrap_width { get; set; } + public virtual signal void changed (); + public virtual signal void move_active (Gtk.ScrollType p0); + [HasEmitter] + public virtual signal bool popdown (); + [HasEmitter] + public virtual signal void popup (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class ComboBoxEntry : Gtk.ComboBox, Atk.Implementor, Gtk.Buildable, Gtk.CellEditable, Gtk.CellLayout { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public ComboBoxEntry (); + public int get_text_column (); + public void set_text_column (int text_column); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public ComboBoxEntry.text (); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public ComboBoxEntry.with_model (Gtk.TreeModel model, int text_column); + public int text_column { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Container : Gtk.Widget, Atk.Implementor, Gtk.Buildable { + public weak Gtk.Widget focus_child; + public uint has_focus_chain; + public uint need_resize; + public uint reallocate_redraws; + [CCode (has_construct_function = false)] + protected Container (); + public void add_with_properties (Gtk.Widget widget, ...); + public void child_get (Gtk.Widget child, ...); + public void child_get_property (Gtk.Widget child, string property_name, GLib.Value value); + public void child_get_valist (Gtk.Widget child, string first_property_name, void* var_args); + public void child_set (Gtk.Widget child, ...); + public void child_set_property (Gtk.Widget child, string property_name, GLib.Value value); + public void child_set_valist (Gtk.Widget child, string first_property_name, void* var_args); + public virtual GLib.Type child_type (); + public static unowned GLib.ParamSpec class_find_child_property (GLib.ObjectClass cclass, string property_name); + public static unowned GLib.ParamSpec class_list_child_properties (GLib.ObjectClass cclass, uint n_properties); + [NoWrapper] + public virtual unowned string composite_name (Gtk.Widget child); + public virtual void forall (Gtk.Callback callback); + [CCode (vfunc_name = "forall")] + public virtual void forall_internal (bool include_internal, Gtk.Callback callback); + public void @foreach (Gtk.Callback callback); + public uint get_border_width (); + [NoWrapper] + public virtual void get_child_property (Gtk.Widget child, uint property_id, GLib.Value value, GLib.ParamSpec pspec); + public GLib.List get_children (); + public bool get_focus_chain (out GLib.List focusable_widgets); + public unowned Gtk.Widget get_focus_child (); + public unowned Gtk.Adjustment get_focus_hadjustment (); + public unowned Gtk.Adjustment get_focus_vadjustment (); + public Gtk.ResizeMode get_resize_mode (); + [CCode (cname = "gtk_container_class_install_child_property")] + public class void install_child_property (uint property_id, GLib.ParamSpec pspec); + public void propagate_expose (Gtk.Widget child, Gdk.EventExpose event); + public void resize_children (); + public void set_border_width (uint border_width); + [NoWrapper] + public virtual void set_child_property (Gtk.Widget child, uint property_id, GLib.Value value, GLib.ParamSpec pspec); + public void set_focus_chain (GLib.List focusable_widgets); + public void set_focus_hadjustment (Gtk.Adjustment adjustment); + public void set_focus_vadjustment (Gtk.Adjustment adjustment); + public void set_reallocate_redraws (bool needs_redraws); + public void set_resize_mode (Gtk.ResizeMode resize_mode); + public void unset_focus_chain (); + public uint border_width { get; set; } + [NoAccessorMethod] + public Gtk.Widget child { set; } + public Gtk.ResizeMode resize_mode { get; set; } + [HasEmitter] + public virtual signal void add (Gtk.Widget widget); + [HasEmitter] + public virtual signal void check_resize (); + [HasEmitter] + public virtual signal void remove (Gtk.Widget widget); + [HasEmitter] + public virtual signal void set_focus_child (Gtk.Widget? widget); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Curve : Gtk.DrawingArea, Atk.Implementor, Gtk.Buildable { + [CCode (array_length = false)] + public weak float[] ctlpoint; + public int cursor_type; + public int grab_point; + public int height; + public int last; + public int num_ctlpoints; + public int num_points; + public weak Gdk.Pixmap pixmap; + public Gdk.Point point; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Curve (); + public void get_vector (int veclen, float[] vector); + public void reset (); + public void set_curve_type (Gtk.CurveType type); + public void set_gamma (float gamma_); + public void set_range (float min_x, float max_x, float min_y, float max_y); + public void set_vector (int veclen, float[] vector); + [NoAccessorMethod] + public Gtk.CurveType curve_type { get; set; } + [NoAccessorMethod] + public float max_x { get; set; } + [NoAccessorMethod] + public float max_y { get; set; } + [NoAccessorMethod] + public float min_x { get; set; } + [NoAccessorMethod] + public float min_y { get; set; } + public virtual signal void curve_type_changed (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Dialog : Gtk.Window, Atk.Implementor, Gtk.Buildable { + public Gtk.HButtonBox action_area; + public weak Gtk.Widget separator; + public Gtk.VBox vbox; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Dialog (); + public void add_action_widget (Gtk.Widget child, int response_id); + public unowned Gtk.Widget add_button (string button_text, int response_id); + public void add_buttons (...); + public unowned Gtk.Widget get_action_area (); + public unowned Gtk.Widget get_content_area (); + public bool get_has_separator (); + public int get_response_for_widget (Gtk.Widget widget); + public unowned Gtk.Widget get_widget_for_response (int response_id); + public int run (); + [CCode (sentinel = "-1")] + public void set_alternative_button_order (...); + public void set_alternative_button_order_from_array (int n_params, int new_order); + public void set_default_response (int response_id); + public void set_has_separator (bool setting); + public void set_response_sensitive (int response_id, bool setting); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Dialog.with_buttons (string? title, Gtk.Window? parent, Gtk.DialogFlags flags, ...); + public bool has_separator { get; set; } + public virtual signal void close (); + [HasEmitter] + public virtual signal void response (int response_id); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class DrawingArea : Gtk.Widget, Atk.Implementor, Gtk.Buildable { + public void* draw_data; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public DrawingArea (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Entry : Gtk.Widget, Atk.Implementor, Gtk.Buildable, Gtk.CellEditable, Gtk.Editable { + public int ascent; + public uint blink_timeout; + public uint button; + public uint cache_includes_preedit; + public weak Pango.Layout cached_layout; + public int current_pos; + public uint cursor_visible; + public int descent; + public int dnd_position; + public int drag_start_x; + public int drag_start_y; + public uint editing_canceled; + public weak Gtk.IMContext im_context; + public uint in_click; + public uint in_drag; + public uint is_cell_renderer; + public uint mouse_cursor_obscured; + public uint need_im_reset; + public weak Gtk.Widget popup_menu; + public uint16 preedit_cursor; + public uint16 preedit_length; + public uint recompute_idle; + public uint resolved_dir; + public uint select_lines; + public uint select_words; + public weak Gdk.Window text_area; + public uint16 text_max_length; + public uint visible; + public uint16 x_n_bytes; + public uint16 x_text_size; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Entry (); + public bool get_activates_default (); + public float get_alignment (); + public unowned Gtk.EntryBuffer get_buffer (); + public unowned Gtk.EntryCompletion get_completion (); + public int get_current_icon_drag_source (); + public unowned Gtk.Adjustment get_cursor_hadjustment (); + public bool get_has_frame (); + public bool get_icon_activatable (Gtk.EntryIconPosition icon_pos); + public int get_icon_at_pos (int x, int y); + public unowned GLib.Icon get_icon_gicon (Gtk.EntryIconPosition icon_pos); + public unowned string get_icon_name (Gtk.EntryIconPosition icon_pos); + public unowned Gdk.Pixbuf get_icon_pixbuf (Gtk.EntryIconPosition icon_pos); + public bool get_icon_sensitive (Gtk.EntryIconPosition icon_pos); + public unowned string get_icon_stock (Gtk.EntryIconPosition icon_pos); + public Gtk.ImageType get_icon_storage_type (Gtk.EntryIconPosition icon_pos); + public unowned string get_icon_tooltip_markup (Gtk.EntryIconPosition icon_pos); + public unowned string get_icon_tooltip_text (Gtk.EntryIconPosition icon_pos); + public unowned Gdk.Window get_icon_window (Gtk.EntryIconPosition icon_pos); + public unowned Gtk.Border get_inner_border (); + public unichar get_invisible_char (); + public unowned Pango.Layout get_layout (); + public void get_layout_offsets (out int x, out int y); + public int get_max_length (); + public bool get_overwrite_mode (); + public double get_progress_fraction (); + public double get_progress_pulse_step (); + public unowned string get_text (); + [NoWrapper] + public virtual void get_text_area_size (int x, int y, int width, int height); + public uint16 get_text_length (); + public unowned Gdk.Window get_text_window (); + public bool get_visibility (); + public int get_width_chars (); + public int layout_index_to_text_index (int layout_index); + public void progress_pulse (); + public void set_activates_default (bool setting); + public void set_alignment (float xalign); + public void set_buffer (Gtk.EntryBuffer buffer); + public void set_completion (Gtk.EntryCompletion completion); + public void set_cursor_hadjustment (Gtk.Adjustment adjustment); + public void set_has_frame (bool setting); + public void set_icon_activatable (Gtk.EntryIconPosition icon_pos, bool activatable); + public void set_icon_drag_source (Gtk.EntryIconPosition icon_pos, Gtk.TargetList target_list, Gdk.DragAction actions); + public void set_icon_from_gicon (Gtk.EntryIconPosition icon_pos, GLib.Icon? icon); + public void set_icon_from_icon_name (Gtk.EntryIconPosition icon_pos, string? icon_name); + public void set_icon_from_pixbuf (Gtk.EntryIconPosition icon_pos, Gdk.Pixbuf? pixbuf); + public void set_icon_from_stock (Gtk.EntryIconPosition icon_pos, string? stock_id); + public void set_icon_sensitive (Gtk.EntryIconPosition icon_pos, bool sensitive); + public void set_icon_tooltip_markup (Gtk.EntryIconPosition icon_pos, string? tooltip); + public void set_icon_tooltip_text (Gtk.EntryIconPosition icon_pos, string? tooltip); + public void set_inner_border (Gtk.Border border); + public void set_invisible_char (unichar ch); + public void set_max_length (int max); + public void set_overwrite_mode (bool overwrite); + public void set_progress_fraction (double fraction); + public void set_progress_pulse_step (double fraction); + public void set_text (string text); + public void set_visibility (bool visible); + public void set_width_chars (int n_chars); + public int text_index_to_layout_index (int text_index); + public void unset_invisible_char (); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Entry.with_buffer (Gtk.EntryBuffer buffer); + public bool activates_default { get; set; } + public Gtk.EntryBuffer buffer { get; set construct; } + [NoAccessorMethod] + public bool caps_lock_warning { get; set; } + [NoAccessorMethod] + public int cursor_position { get; } + [NoAccessorMethod] + public bool editable { get; set; } + public bool has_frame { get; set; } + [NoAccessorMethod] + public string im_module { owned get; set; } + public Gtk.Border inner_border { get; set; } + public uint invisible_char { get; set; } + [NoAccessorMethod] + public bool invisible_char_set { get; set; } + public int max_length { get; set; } + public bool overwrite_mode { get; set; } + [NoAccessorMethod] + public bool primary_icon_activatable { get; set; } + [NoAccessorMethod] + public GLib.Icon primary_icon_gicon { owned get; set; } + [NoAccessorMethod] + public string primary_icon_name { owned get; set; } + [NoAccessorMethod] + public Gdk.Pixbuf primary_icon_pixbuf { owned get; set; } + [NoAccessorMethod] + public bool primary_icon_sensitive { get; set; } + [NoAccessorMethod] + public string primary_icon_stock { owned get; set; } + [NoAccessorMethod] + public Gtk.ImageType primary_icon_storage_type { get; } + [NoAccessorMethod] + public string primary_icon_tooltip_markup { owned get; set; } + [NoAccessorMethod] + public string primary_icon_tooltip_text { owned get; set; } + public double progress_fraction { get; set; } + public double progress_pulse_step { get; set; } + [NoAccessorMethod] + public int scroll_offset { get; } + [NoAccessorMethod] + public bool secondary_icon_activatable { get; set; } + [NoAccessorMethod] + public GLib.Icon secondary_icon_gicon { owned get; set; } + [NoAccessorMethod] + public string secondary_icon_name { owned get; set; } + [NoAccessorMethod] + public Gdk.Pixbuf secondary_icon_pixbuf { owned get; set; } + [NoAccessorMethod] + public bool secondary_icon_sensitive { get; set; } + [NoAccessorMethod] + public string secondary_icon_stock { owned get; set; } + [NoAccessorMethod] + public Gtk.ImageType secondary_icon_storage_type { get; } + [NoAccessorMethod] + public string secondary_icon_tooltip_markup { owned get; set; } + [NoAccessorMethod] + public string secondary_icon_tooltip_text { owned get; set; } + [NoAccessorMethod] + public int selection_bound { get; } + [NoAccessorMethod] + public Gtk.ShadowType shadow_type { get; set; } + public string text { get; set; } + public uint text_length { get; } + [NoAccessorMethod] + public bool truncate_multiline { get; set; } + public bool visibility { get; set; } + public int width_chars { get; set; } + [NoAccessorMethod] + public float xalign { get; set; } + public virtual signal void activate (); + public virtual signal void backspace (); + public virtual signal void copy_clipboard (); + public virtual signal void cut_clipboard (); + public virtual signal void delete_from_cursor (Gtk.DeleteType type, int count); + public virtual signal void icon_press (Gtk.EntryIconPosition p0, Gdk.Event p1); + public virtual signal void icon_release (Gtk.EntryIconPosition p0, Gdk.Event p1); + public virtual signal void insert_at_cursor (string str); + public virtual signal void move_cursor (Gtk.MovementStep step, int count, bool extend_selection); + public virtual signal void paste_clipboard (); + public virtual signal void populate_popup (Gtk.Menu menu); + public virtual signal void preedit_changed (string p0); + public virtual signal void toggle_overwrite (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class EntryBuffer : GLib.Object { + [CCode (has_construct_function = false)] + public EntryBuffer (uint8[] initial_chars); + public virtual uint delete_text (uint position, int n_chars); + public void emit_deleted_text (uint position, uint n_chars); + public void emit_inserted_text (uint position, uint8[] chars); + public size_t get_bytes (); + public virtual uint get_length (); + public int get_max_length (); + public virtual unowned string get_text (); + public virtual uint insert_text (uint position, uint8[] chars); + public void set_max_length (int max_length); + public void set_text (uint8[] chars); + public uint length { get; } + public int max_length { get; set; } + public string text { get; set; } + public virtual signal void deleted_text (uint position, uint n_chars); + public virtual signal void inserted_text (uint position, string chars, uint n_chars); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class EntryCompletion : GLib.Object, Gtk.Buildable, Gtk.CellLayout { + [CCode (has_construct_function = false)] + public EntryCompletion (); + public void complete (); + public void delete_action (int index_); + public unowned string get_completion_prefix (); + public unowned Gtk.Widget get_entry (); + public bool get_inline_completion (); + public bool get_inline_selection (); + public int get_minimum_key_length (); + public unowned Gtk.TreeModel get_model (); + public bool get_popup_completion (); + public bool get_popup_set_width (); + public bool get_popup_single_match (); + public int get_text_column (); + public void insert_action_markup (int index_, string markup); + public void insert_action_text (int index_, string text); + public void set_inline_completion (bool inline_completion); + public void set_inline_selection (bool inline_selection); + public void set_match_func (owned Gtk.EntryCompletionMatchFunc func); + public void set_minimum_key_length (int length); + public void set_model (Gtk.TreeModel? model); + public void set_popup_completion (bool popup_completion); + public void set_popup_set_width (bool popup_set_width); + public void set_popup_single_match (bool popup_single_match); + public void set_text_column (int column); + public bool inline_completion { get; set; } + public bool inline_selection { get; set; } + public int minimum_key_length { get; set; } + public Gtk.TreeModel model { get; set; } + public bool popup_completion { get; set; } + public bool popup_set_width { get; set; } + public bool popup_single_match { get; set; } + public int text_column { get; set; } + public virtual signal void action_activated (int index_); + public virtual signal bool cursor_on_match (Gtk.TreeModel model, Gtk.TreeIter iter); + [HasEmitter] + public virtual signal bool insert_prefix (string prefix); + public virtual signal bool match_selected (Gtk.TreeModel model, Gtk.TreeIter iter); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class EventBox : Gtk.Bin, Atk.Implementor, Gtk.Buildable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public EventBox (); + public bool get_above_child (); + public bool get_visible_window (); + public void set_above_child (bool above_child); + public void set_visible_window (bool visible_window); + public bool above_child { get; set; } + public bool visible_window { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Expander : Gtk.Bin, Atk.Implementor, Gtk.Buildable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Expander (string label); + public bool get_expanded (); + public unowned string get_label (); + public unowned Gtk.Widget get_label_widget (); + public int get_spacing (); + public bool get_use_markup (); + public bool get_use_underline (); + public void set_expanded (bool expanded); + public void set_label (string label); + public void set_label_widget (Gtk.Widget label_widget); + public void set_spacing (int spacing); + public void set_use_markup (bool use_markup); + public void set_use_underline (bool use_underline); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Expander.with_mnemonic (string label); + public bool expanded { get; set construct; } + public string label { get; set construct; } + public Gtk.Widget label_widget { get; set; } + public int spacing { get; set; } + public bool use_markup { get; set construct; } + public bool use_underline { get; set construct; } + public virtual signal void activate (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class FileChooserButton : Gtk.HBox, Atk.Implementor, Gtk.Buildable, Gtk.Orientable, Gtk.FileChooser { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public FileChooserButton (string title, Gtk.FileChooserAction action); + public bool get_focus_on_click (); + public unowned string get_title (); + public int get_width_chars (); + public void set_focus_on_click (bool focus_on_click); + public void set_title (string title); + public void set_width_chars (int n_chars); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public FileChooserButton.with_dialog (Gtk.Widget dialog); + public Gtk.FileChooser dialog { construct; } + public bool focus_on_click { get; set; } + public string title { get; set; } + public int width_chars { get; set; } + public virtual signal void file_set (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class FileChooserDialog : Gtk.Dialog, Atk.Implementor, Gtk.Buildable, Gtk.FileChooser { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public FileChooserDialog (string? title, Gtk.Window? parent, Gtk.FileChooserAction action, ...); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class FileChooserWidget : Gtk.VBox, Atk.Implementor, Gtk.Buildable, Gtk.Orientable, Gtk.FileChooser, Gtk.FileChooserEmbed { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public FileChooserWidget (Gtk.FileChooserAction action); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class FileFilter : Gtk.Object { + [CCode (has_construct_function = false)] + public FileFilter (); + public void add_custom (Gtk.FileFilterFlags needed, owned Gtk.FileFilterFunc func); + public void add_mime_type (string mime_type); + public void add_pattern (string pattern); + public void add_pixbuf_formats (); + public bool filter (Gtk.FileFilterInfo filter_info); + public unowned string get_name (); + public Gtk.FileFilterFlags get_needed (); + public void set_name (string name); + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class FileFilterInfo { + public Gtk.FileFilterFlags contains; + public weak string display_name; + public weak string filename; + public weak string mime_type; + public weak string uri; + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Fixed : Gtk.Container, Atk.Implementor, Gtk.Buildable { + public weak GLib.List children; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Fixed (); + public bool get_has_window (); + public void move (Gtk.Widget widget, int x, int y); + public void put (Gtk.Widget widget, int x, int y); + public void set_has_window (bool has_window); + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class FixedChild { + public weak Gtk.Widget widget; + public int x; + public int y; + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class FontButton : Gtk.Button, Atk.Implementor, Gtk.Buildable, Gtk.Activatable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public FontButton (); + public unowned string get_font_name (); + public bool get_show_size (); + public bool get_show_style (); + public unowned string get_title (); + public bool get_use_font (); + public bool get_use_size (); + public bool set_font_name (string fontname); + public void set_show_size (bool show_size); + public void set_show_style (bool show_style); + public void set_title (string title); + public void set_use_font (bool use_font); + public void set_use_size (bool use_size); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public FontButton.with_font (string fontname); + public string font_name { get; set; } + public bool show_size { get; set; } + public bool show_style { get; set; } + public string title { get; set; } + public bool use_font { get; set; } + public bool use_size { get; set; } + public virtual signal void font_set (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class FontSelection : Gtk.VBox, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + public weak Pango.FontFace face; + public weak Gtk.Widget face_list; + public weak Pango.FontFamily family; + public weak Gtk.Widget family_list; + public weak Gtk.Widget filter_button; + public weak Gtk.Widget font_entry; + public weak Gtk.Widget font_style_entry; + public weak Gtk.Widget pixels_button; + public weak Gtk.Widget points_button; + public weak Gtk.Widget preview_entry; + public int size; + public weak Gtk.Widget size_entry; + public weak Gtk.Widget size_list; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public FontSelection (); + public unowned Pango.FontFace get_face (); + public unowned Gtk.Widget get_face_list (); + public unowned Pango.FontFamily get_family (); + public unowned Gtk.Widget get_family_list (); + public unowned string get_font_name (); + public unowned Gtk.Widget get_preview_entry (); + public unowned string get_preview_text (); + public int get_size (); + public unowned Gtk.Widget get_size_entry (); + public unowned Gtk.Widget get_size_list (); + public bool set_font_name (string fontname); + public void set_preview_text (string text); + [NoAccessorMethod] + public Gdk.Font font { owned get; } + public string font_name { get; set; } + public string preview_text { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class FontSelectionDialog : Gtk.Dialog, Atk.Implementor, Gtk.Buildable { + public weak Gtk.Widget action_area; + public weak Gtk.Widget apply_button; + public bool auto_resize; + public weak Gtk.Widget cancel_button; + public int dialog_width; + public weak Gtk.Widget fontsel; + public weak Gtk.Widget main_vbox; + public weak Gtk.Widget ok_button; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public FontSelectionDialog (string title); + public unowned Gtk.Widget get_cancel_button (); + public unowned string get_font_name (); + public unowned Gtk.Widget get_ok_button (); + public unowned string get_preview_text (); + public bool set_font_name (string fontname); + public void set_preview_text (string text); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Frame : Gtk.Bin, Atk.Implementor, Gtk.Buildable { + public Gtk.Allocation child_allocation; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Frame (string? label); + [NoWrapper] + public virtual void compute_child_allocation (Gtk.Allocation allocation); + public unowned string get_label (); + public void get_label_align (float xalign, float yalign); + public unowned Gtk.Widget get_label_widget (); + public Gtk.ShadowType get_shadow_type (); + public void set_label (string label); + public void set_label_align (float xalign, float yalign); + public void set_label_widget (Gtk.Widget label_widget); + public void set_shadow_type (Gtk.ShadowType type); + public string label { get; set; } + public Gtk.Widget label_widget { get; set; } + [NoAccessorMethod] + public float label_xalign { get; set; } + [NoAccessorMethod] + public float label_yalign { get; set; } + [NoAccessorMethod] + public Gtk.ShadowType shadow { get; set; } + public Gtk.ShadowType shadow_type { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class GammaCurve : Gtk.VBox, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + [CCode (array_length = false)] + public weak Gtk.Widget[] button; + public weak Gtk.Widget curve; + public float gamma; + public weak Gtk.Widget gamma_dialog; + public weak Gtk.Widget gamma_text; + public weak Gtk.Widget table; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public GammaCurve (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class HBox : Gtk.Box, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public HBox (bool homogeneous, int spacing); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class HButtonBox : Gtk.ButtonBox, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public HButtonBox (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class HPaned : Gtk.Paned, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public HPaned (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class HRuler : Gtk.Ruler, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public HRuler (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class HSV : Gtk.Widget, Atk.Implementor, Gtk.Buildable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public HSV (); + public void get_color (double h, double s, double v); + public void get_metrics (int size, int ring_width); + public bool is_adjusting (); + public void set_color (double h, double s, double v); + public void set_metrics (int size, int ring_width); + public static void to_rgb (double h, double s, double v, out double r, out double g, out double b); + public virtual signal void changed (); + public virtual signal void move (Gtk.DirectionType type); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class HScale : Gtk.Scale, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public HScale (Gtk.Adjustment? adjustment); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public HScale.with_range (double min, double max, double step); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class HScrollbar : Gtk.Scrollbar, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public HScrollbar (Gtk.Adjustment? adjustment); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class HSeparator : Gtk.Separator, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public HSeparator (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class HandleBox : Gtk.Bin, Atk.Implementor, Gtk.Buildable { + public Gtk.Allocation attach_allocation; + public weak Gdk.Window bin_window; + public int deskoff_x; + public int deskoff_y; + public Gtk.Allocation float_allocation; + public weak Gdk.Window float_window; + public uint float_window_mapped; + public uint in_drag; + public uint shrink_on_detach; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public HandleBox (); + public bool get_child_detached (); + public Gtk.PositionType get_handle_position (); + public Gtk.ShadowType get_shadow_type (); + public Gtk.PositionType get_snap_edge (); + public void set_handle_position (Gtk.PositionType position); + public void set_shadow_type (Gtk.ShadowType type); + public void set_snap_edge (Gtk.PositionType edge); + public bool child_detached { get; } + public Gtk.PositionType handle_position { get; set; } + [NoAccessorMethod] + public Gtk.ShadowType shadow { get; set; } + public Gtk.ShadowType shadow_type { get; set; } + public Gtk.PositionType snap_edge { get; set; } + [NoAccessorMethod] + public bool snap_edge_set { get; set; } + public virtual signal void child_attached (Gtk.Widget child); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class IMContext : GLib.Object { + [CCode (has_construct_function = false)] + protected IMContext (); + public virtual bool filter_keypress (Gdk.EventKey event); + public virtual void focus_in (); + public virtual void focus_out (); + public virtual void get_preedit_string (out unowned string str, out Pango.AttrList attrs, out int cursor_pos); + public virtual bool get_surrounding (out unowned string text, out int cursor_index); + public virtual void reset (); + public virtual void set_client_window (Gdk.Window window); + public virtual void set_cursor_location (Gdk.Rectangle area); + public virtual void set_surrounding (string text, int len, int cursor_index); + public virtual void set_use_preedit (bool use_preedit); + public virtual signal void commit (string str); + [HasEmitter] + public virtual signal bool delete_surrounding (int offset, int n_chars); + public virtual signal void preedit_changed (); + public virtual signal void preedit_end (); + public virtual signal void preedit_start (); + public virtual signal bool retrieve_surrounding (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class IMContextSimple : Gtk.IMContext { + [CCode (array_length = false)] + public weak uint[] compose_buffer; + public uint in_hex_sequence; + public uint modifiers_dropped; + public weak GLib.SList tables; + public unichar tentative_match; + public int tentative_match_len; + [CCode (type = "GtkIMContext*", has_construct_function = false)] + public IMContextSimple (); + public void add_table (uint16 data, int max_seq_len, int n_seqs); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class IMMulticontext : Gtk.IMContext { + public weak string context_id; + public weak Gtk.IMContext slave; + [CCode (type = "GtkIMContext*", has_construct_function = false)] + public IMMulticontext (); + public void append_menuitems (Gtk.MenuShell menushell); + public unowned string get_context_id (); + public void set_context_id (string context_id); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class IconFactory : GLib.Object, Gtk.Buildable { + public weak GLib.HashTable icons; + [CCode (has_construct_function = false)] + public IconFactory (); + public void add (string stock_id, Gtk.IconSet icon_set); + public void add_default (); + public unowned Gtk.IconSet lookup (string stock_id); + public static unowned Gtk.IconSet lookup_default (string stock_id); + public void remove_default (); + } + [Compact] + [CCode (copy_function = "gtk_icon_info_copy", type_id = "GTK_TYPE_ICON_INFO", cheader_filename = "gtk/gtk.h")] + public class IconInfo { + public Gtk.IconInfo copy (); + [CCode (has_construct_function = false)] + public IconInfo.for_pixbuf (Gtk.IconTheme icon_theme, Gdk.Pixbuf pixbuf); + public bool get_attach_points (Gdk.Point[] points); + public int get_base_size (); + public unowned Gdk.Pixbuf get_builtin_pixbuf (); + public unowned string get_display_name (); + public bool get_embedded_rect (out Gdk.Rectangle rectangle); + public unowned string get_filename (); + public Gdk.Pixbuf load_icon () throws GLib.Error; + public void set_raw_coordinates (bool raw_coordinates); + } + [Compact] + [CCode (ref_function = "gtk_icon_set_ref", unref_function = "gtk_icon_set_unref", type_id = "GTK_TYPE_ICON_SET", cheader_filename = "gtk/gtk.h")] + public class IconSet { + [CCode (has_construct_function = false)] + public IconSet (); + public void add_source (Gtk.IconSource source); + public Gtk.IconSet copy (); + [CCode (has_construct_function = false)] + public IconSet.from_pixbuf (Gdk.Pixbuf pixbuf); + public void get_sizes (Gtk.IconSize[] sizes); + public unowned Gdk.Pixbuf render_icon (Gtk.Style style, Gtk.TextDirection direction, Gtk.StateType state, Gtk.IconSize size, Gtk.Widget widget, string detail); + } + [Compact] + [CCode (copy_function = "gtk_icon_source_copy", type_id = "GTK_TYPE_ICON_SOURCE", cheader_filename = "gtk/gtk.h")] + public class IconSource { + [CCode (has_construct_function = false)] + public IconSource (); + public Gtk.IconSource copy (); + public Gtk.TextDirection get_direction (); + public bool get_direction_wildcarded (); + public unowned string get_filename (); + public unowned string get_icon_name (); + public unowned Gdk.Pixbuf get_pixbuf (); + public Gtk.IconSize get_size (); + public bool get_size_wildcarded (); + public Gtk.StateType get_state (); + public bool get_state_wildcarded (); + public void set_direction (Gtk.TextDirection direction); + public void set_direction_wildcarded (bool setting); + public void set_filename (string filename); + public void set_icon_name (string icon_name); + public void set_pixbuf (Gdk.Pixbuf pixbuf); + public void set_size (Gtk.IconSize size); + public void set_size_wildcarded (bool setting); + public void set_state (Gtk.StateType state); + public void set_state_wildcarded (bool setting); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class IconTheme : GLib.Object { + [CCode (has_construct_function = false)] + public IconTheme (); + public static void add_builtin_icon (string icon_name, int size, Gdk.Pixbuf pixbuf); + public void append_search_path (string path); + public Gtk.IconInfo choose_icon ([CCode (array_length = false, array_null_terminated = true)] string[] icon_names, int size, Gtk.IconLookupFlags flags); + public static GLib.Quark error_quark (); + public static unowned Gtk.IconTheme get_default (); + public unowned string get_example_icon_name (); + public static unowned Gtk.IconTheme get_for_screen (Gdk.Screen screen); + public int get_icon_sizes (string icon_name); + public void get_search_path (string path, int n_elements); + public bool has_icon (string icon_name); + public GLib.List list_contexts (); + public GLib.List list_icons (string context); + public Gdk.Pixbuf? load_icon (string icon_name, int size, Gtk.IconLookupFlags flags) throws GLib.Error; + public Gtk.IconInfo lookup_by_gicon (GLib.Icon icon, int size, Gtk.IconLookupFlags flags); + public Gtk.IconInfo lookup_icon (string icon_name, int size, Gtk.IconLookupFlags flags); + public void prepend_search_path (string path); + public bool rescan_if_needed (); + public void set_custom_theme (string theme_name); + public void set_screen (Gdk.Screen screen); + public void set_search_path (string[] path, int n_elements); + public virtual signal void changed (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class IconView : Gtk.Container, Atk.Implementor, Gtk.Buildable, Gtk.CellLayout { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public IconView (); + public void convert_widget_to_bin_window_coords (int wx, int wy, int bx, int by); + public unowned Gdk.Pixmap create_drag_icon (Gtk.TreePath path); + public void enable_model_drag_dest (Gtk.TargetEntry[] targets, Gdk.DragAction actions); + public void enable_model_drag_source (Gdk.ModifierType start_button_mask, Gtk.TargetEntry[] targets, Gdk.DragAction actions); + public int get_column_spacing (); + public int get_columns (); + public bool get_cursor (out Gtk.TreePath path, out unowned Gtk.CellRenderer cell); + public bool get_dest_item_at_pos (int drag_x, int drag_y, out unowned Gtk.TreePath path, Gtk.IconViewDropPosition pos); + public void get_drag_dest_item (out unowned Gtk.TreePath path, Gtk.IconViewDropPosition pos); + public bool get_item_at_pos (int x, int y, out unowned Gtk.TreePath path, out unowned Gtk.CellRenderer cell); + public int get_item_padding (); + public int get_item_width (); + public int get_margin (); + public int get_markup_column (); + public unowned Gtk.TreeModel get_model (); + public Gtk.Orientation get_orientation (); + public unowned Gtk.TreePath get_path_at_pos (int x, int y); + public int get_pixbuf_column (); + public bool get_reorderable (); + public int get_row_spacing (); + public GLib.List get_selected_items (); + public Gtk.SelectionMode get_selection_mode (); + public int get_spacing (); + public int get_text_column (); + public int get_tooltip_column (); + public bool get_tooltip_context (out int x, out int y, bool keyboard_tip, out unowned Gtk.TreeModel model, out unowned Gtk.TreePath path, out Gtk.TreeIter iter); + public bool get_visible_range (out unowned Gtk.TreePath start_path, out unowned Gtk.TreePath end_path); + public bool path_is_selected (Gtk.TreePath path); + public void scroll_to_path (Gtk.TreePath path, bool use_align, float row_align, float col_align); + public void select_path (Gtk.TreePath path); + public void selected_foreach (Gtk.IconViewForeachFunc func); + public void set_column_spacing (int column_spacing); + public void set_columns (int columns); + public void set_cursor (Gtk.TreePath path, Gtk.CellRenderer? cell, bool start_editing); + public void set_drag_dest_item (Gtk.TreePath path, Gtk.IconViewDropPosition pos); + public void set_item_padding (int item_padding); + public void set_item_width (int item_width); + public void set_margin (int margin); + public void set_markup_column (int column); + public void set_model (Gtk.TreeModel? model); + public void set_orientation (Gtk.Orientation orientation); + public void set_pixbuf_column (int column); + public void set_reorderable (bool reorderable); + public void set_row_spacing (int row_spacing); + public void set_selection_mode (Gtk.SelectionMode mode); + public void set_spacing (int spacing); + public void set_text_column (int column); + public void set_tooltip_cell (Gtk.Tooltip tooltip, Gtk.TreePath path, Gtk.CellRenderer cell); + public void set_tooltip_column (int column); + public void set_tooltip_item (Gtk.Tooltip tooltip, Gtk.TreePath path); + public void unselect_path (Gtk.TreePath path); + public void unset_model_drag_dest (); + public void unset_model_drag_source (); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public IconView.with_model (Gtk.TreeModel model); + public int column_spacing { get; set; } + public int columns { get; set; } + public int item_padding { get; set; } + public int item_width { get; set; } + public int margin { get; set; } + public int markup_column { get; set; } + public Gtk.TreeModel model { get; set; } + public Gtk.Orientation orientation { get; set; } + public int pixbuf_column { get; set; } + public bool reorderable { get; set; } + public int row_spacing { get; set; } + public Gtk.SelectionMode selection_mode { get; set; } + public int spacing { get; set; } + public int text_column { get; set; } + public int tooltip_column { get; set; } + public virtual signal bool activate_cursor_item (); + [HasEmitter] + public virtual signal void item_activated (Gtk.TreePath path); + public virtual signal bool move_cursor (Gtk.MovementStep step, int count); + public virtual signal void select_all (); + public virtual signal void select_cursor_item (); + public virtual signal void selection_changed (); + public virtual signal void set_scroll_adjustments (Gtk.Adjustment hadjustment, Gtk.Adjustment vadjustment); + public virtual signal void toggle_cursor_item (); + public virtual signal void unselect_all (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Image : Gtk.Misc, Atk.Implementor, Gtk.Buildable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Image (); + public void clear (); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Image.from_animation (Gdk.PixbufAnimation animation); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Image.from_file (string filename); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Image.from_gicon (GLib.Icon icon, Gtk.IconSize size); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Image.from_icon_name (string icon_name, Gtk.IconSize size); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Image.from_icon_set (Gtk.IconSet icon_set, Gtk.IconSize size); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Image.from_image (Gdk.Image image, Gdk.Bitmap mask); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Image.from_pixbuf (Gdk.Pixbuf pixbuf); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Image.from_pixmap (Gdk.Pixmap pixmap, Gdk.Bitmap mask); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Image.from_stock (string stock_id, Gtk.IconSize size); + public unowned Gdk.PixbufAnimation get_animation (); + public void get_gicon (out unowned GLib.Icon gicon, Gtk.IconSize size); + public void get_icon_name (out unowned string icon_name, out Gtk.IconSize size); + public void get_icon_set (out unowned Gtk.IconSet icon_set, out Gtk.IconSize size); + public void get_image (out unowned Gdk.Image gdk_image, out unowned Gdk.Bitmap mask); + public unowned Gdk.Pixbuf get_pixbuf (); + public int get_pixel_size (); + public void get_pixmap (out unowned Gdk.Pixmap pixmap, out unowned Gdk.Bitmap mask); + public void get_stock (out string stock_id, out Gtk.IconSize size); + public Gtk.ImageType get_storage_type (); + public void set_from_animation (Gdk.PixbufAnimation animation); + public void set_from_file (string filename); + public void set_from_gicon (GLib.Icon icon, Gtk.IconSize size); + public void set_from_icon_name (string icon_name, Gtk.IconSize size); + public void set_from_icon_set (Gtk.IconSet icon_set, Gtk.IconSize size); + public void set_from_image (Gdk.Image gdk_image, Gdk.Bitmap mask); + public void set_from_pixbuf (Gdk.Pixbuf pixbuf); + public void set_from_pixmap (Gdk.Pixmap? pixmap, Gdk.Bitmap? mask); + public void set_from_stock (string stock_id, Gtk.IconSize size); + public void set_pixel_size (int pixel_size); + [NoAccessorMethod] + public string file { owned get; set; } + [NoAccessorMethod] + public GLib.Icon gicon { owned get; set; } + [NoAccessorMethod] + public string icon_name { owned get; set; } + [NoAccessorMethod] + public Gtk.IconSet icon_set { owned get; set; } + [NoAccessorMethod] + public int icon_size { get; set; } + [NoAccessorMethod] + public Gdk.Image image { owned get; set; } + [NoAccessorMethod] + public Gdk.Pixmap mask { owned get; set; } + [NoAccessorMethod] + public Gdk.Pixbuf pixbuf { owned get; set; } + [NoAccessorMethod] + public Gdk.PixbufAnimation pixbuf_animation { owned get; set; } + public int pixel_size { get; set; } + [NoAccessorMethod] + public Gdk.Pixmap pixmap { owned get; set; } + [NoAccessorMethod] + public string stock { owned get; set; } + public Gtk.ImageType storage_type { get; } + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class ImageAnimationData { + public weak Gdk.PixbufAnimation anim; + public uint frame_timeout; + public weak Gdk.PixbufAnimationIter iter; + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class ImageGIconData { + public weak GLib.Icon icon; + public weak Gdk.Pixbuf pixbuf; + public uint theme_change_id; + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class ImageIconNameData { + public weak string icon_name; + public weak Gdk.Pixbuf pixbuf; + public uint theme_change_id; + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class ImageIconSetData { + public weak Gtk.IconSet icon_set; + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class ImageImageData { + public weak Gdk.Image image; + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class ImageMenuItem : Gtk.MenuItem, Atk.Implementor, Gtk.Buildable, Gtk.Activatable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public ImageMenuItem (); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public ImageMenuItem.from_stock (string stock_id, Gtk.AccelGroup? accel_group); + public bool get_always_show_image (); + public unowned Gtk.Widget get_image (); + public bool get_use_stock (); + public void set_accel_group (Gtk.AccelGroup accel_group); + public void set_always_show_image (bool always_show); + public void set_image (Gtk.Widget image); + public void set_use_stock (bool use_stock); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public ImageMenuItem.with_label (string label); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public ImageMenuItem.with_mnemonic (string label); + public Gtk.AccelGroup accel_group { set; } + public bool always_show_image { get; set construct; } + public Gtk.Widget image { get; set; } + public bool use_stock { get; set construct; } + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class ImagePixbufData { + public weak Gdk.Pixbuf pixbuf; + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class ImagePixmapData { + public weak Gdk.Pixmap pixmap; + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class ImageStockData { + public weak string stock_id; + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class InfoBar : Gtk.HBox, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public InfoBar (); + public void add_action_widget (Gtk.Widget child, int response_id); + public unowned Gtk.Widget add_button (string button_text, int response_id); + public void add_buttons (...); + public unowned Gtk.Widget get_action_area (); + public unowned Gtk.Widget get_content_area (); + public Gtk.MessageType get_message_type (); + public void set_default_response (int response_id); + public void set_message_type (Gtk.MessageType message_type); + public void set_response_sensitive (int response_id, bool setting); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public InfoBar.with_buttons (...); + public Gtk.MessageType message_type { get; set construct; } + public virtual signal void close (); + [HasEmitter] + public virtual signal void response (int response_id); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class InputDialog : Gtk.Dialog, Atk.Implementor, Gtk.Buildable { + [CCode (array_length = false)] + public weak Gtk.Widget[] axis_items; + public weak Gtk.Widget axis_list; + public weak Gtk.Widget axis_listbox; + public weak Gtk.Widget close_button; + public weak Gdk.Device current_device; + public weak Gtk.Widget keys_list; + public weak Gtk.Widget keys_listbox; + public weak Gtk.Widget mode_optionmenu; + public weak Gtk.Widget save_button; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public InputDialog (); + public virtual signal void disable_device (Gdk.Device device); + public virtual signal void enable_device (Gdk.Device device); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Invisible : Gtk.Widget, Atk.Implementor, Gtk.Buildable { + public bool has_user_ref_count; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Invisible (); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Invisible.for_screen (Gdk.Screen screen); + public unowned Gdk.Screen get_screen (); + public void set_screen (Gdk.Screen screen); + public Gdk.Screen screen { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Item : Gtk.Bin, Atk.Implementor, Gtk.Buildable { + [CCode (has_construct_function = false)] + protected Item (); + [HasEmitter] + public virtual signal void deselect (); + [HasEmitter] + public virtual signal void select (); + [HasEmitter] + public virtual signal void toggle (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Label : Gtk.Misc, Atk.Implementor, Gtk.Buildable { + public weak Pango.AttrList attrs; + public weak Pango.AttrList effective_attrs; + public uint have_transform; + public uint in_click; + public uint jtype; + public weak Pango.Layout layout; + public weak Gtk.Window mnemonic_window; + public uint pattern_set; + public weak Gtk.LabelSelectionInfo select_info; + public uint track_links; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Label (string? str); + public double get_angle (); + public unowned Pango.AttrList get_attributes (); + public unowned string get_current_uri (); + public Pango.EllipsizeMode get_ellipsize (); + public Gtk.Justification get_justify (); + public unowned string get_label (); + public unowned Pango.Layout get_layout (); + public void get_layout_offsets (out int x, out int y); + public bool get_line_wrap (); + public Pango.WrapMode get_line_wrap_mode (); + public int get_max_width_chars (); + public uint get_mnemonic_keyval (); + public unowned Gtk.Widget get_mnemonic_widget (); + public bool get_selectable (); + public bool get_selection_bounds (out int start, out int end); + public bool get_single_line_mode (); + public unowned string get_text (); + public bool get_track_visited_links (); + public bool get_use_markup (); + public bool get_use_underline (); + public int get_width_chars (); + public void select_region (int start_offset, int end_offset); + public void set_angle (double angle); + public void set_attributes (Pango.AttrList attrs); + public void set_ellipsize (Pango.EllipsizeMode mode); + public void set_justify (Gtk.Justification jtype); + public void set_label (string str); + public void set_line_wrap (bool wrap); + public void set_line_wrap_mode (Pango.WrapMode wrap_mode); + public void set_markup (string str); + public void set_markup_with_mnemonic (string str); + public void set_max_width_chars (int n_chars); + public void set_mnemonic_widget (Gtk.Widget widget); + public void set_pattern (string pattern); + public void set_selectable (bool setting); + public void set_single_line_mode (bool single_line_mode); + public void set_text (string str); + public void set_text_with_mnemonic (string str); + public void set_track_visited_links (bool track_links); + public void set_use_markup (bool setting); + public void set_use_underline (bool setting); + public void set_width_chars (int n_chars); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Label.with_mnemonic (string str); + public double angle { get; set; } + public Pango.AttrList attributes { get; set; } + [NoAccessorMethod] + public int cursor_position { get; } + public Pango.EllipsizeMode ellipsize { get; set; } + public Gtk.Justification justify { get; set; } + public string label { get; set; } + public int max_width_chars { get; set; } + public uint mnemonic_keyval { get; } + public Gtk.Widget mnemonic_widget { get; set; } + public string pattern { set; } + public bool selectable { get; set; } + [NoAccessorMethod] + public int selection_bound { get; } + public bool single_line_mode { get; set; } + public bool track_visited_links { get; set; } + public bool use_markup { get; set; } + public bool use_underline { get; set; } + public int width_chars { get; set; } + [NoAccessorMethod] + public bool wrap { get; set; } + [NoAccessorMethod] + public Pango.WrapMode wrap_mode { get; set; } + public virtual signal void activate_current_link (); + public virtual signal bool activate_link (string uri); + public virtual signal void copy_clipboard (); + public virtual signal void move_cursor (Gtk.MovementStep step, int count, bool extend_selection); + public virtual signal void populate_popup (Gtk.Menu menu); + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class LabelSelectionInfo { + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Layout : Gtk.Container, Atk.Implementor, Gtk.Buildable { + public weak Gdk.Window bin_window; + public weak GLib.List children; + public uint freeze_count; + public int scroll_x; + public int scroll_y; + public Gdk.VisibilityState visibility; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Layout (Gtk.Adjustment? hadjustment = null, Gtk.Adjustment? vadjustment = null); + public unowned Gdk.Window get_bin_window (); + public unowned Gtk.Adjustment get_hadjustment (); + public void get_size (out uint width, out uint height); + public unowned Gtk.Adjustment get_vadjustment (); + public void move (Gtk.Widget child_widget, int x, int y); + public void put (Gtk.Widget child_widget, int x, int y); + public void set_hadjustment (Gtk.Adjustment adjustment); + public void set_size (uint width, uint height); + public void set_vadjustment (Gtk.Adjustment adjustment); + public Gtk.Adjustment hadjustment { get; set; } + [NoAccessorMethod] + public uint height { get; set; } + public Gtk.Adjustment vadjustment { get; set; } + [NoAccessorMethod] + public uint width { get; set; } + public virtual signal void set_scroll_adjustments (Gtk.Adjustment hadjustment, Gtk.Adjustment vadjustment); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class LinkButton : Gtk.Button, Atk.Implementor, Gtk.Buildable, Gtk.Activatable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public LinkButton (string uri); + public unowned string get_uri (); + public bool get_visited (); + public void set_uri (string uri); + public static void set_uri_hook (owned Gtk.LinkButtonUriFunc func); + public void set_visited (bool visited); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public LinkButton.with_label (string uri, string label); + public string uri { get; set; } + public bool visited { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class ListStore : GLib.Object, Gtk.Buildable, Gtk.TreeModel, Gtk.TreeSortable, Gtk.TreeDragSource, Gtk.TreeDragDest { + [CCode (array_length = false)] + public weak GLib.Type[] column_headers; + public uint columns_dirty; + public void* default_sort_data; + public weak GLib.DestroyNotify default_sort_destroy; + public weak Gtk.TreeIterCompareFunc default_sort_func; + public int length; + public int n_columns; + public Gtk.SortType order; + public void* seq; + public int sort_column_id; + public weak GLib.List sort_list; + public int stamp; + [CCode (sentinel = "", has_construct_function = false)] + public ListStore (int n_columns, ...); + public void append (out Gtk.TreeIter iter); + public void clear (); + public void insert (out Gtk.TreeIter iter, int position); + public void insert_after (out Gtk.TreeIter iter, Gtk.TreeIter? sibling); + public void insert_before (out Gtk.TreeIter iter, Gtk.TreeIter? sibling); + [CCode (sentinel = "-1")] + public void insert_with_values (out Gtk.TreeIter iter, int position, ...); + public void insert_with_valuesv (out Gtk.TreeIter iter, int position, int columns, GLib.Value[] values); + public bool iter_is_valid (Gtk.TreeIter iter); + public void move_after (ref Gtk.TreeIter iter, Gtk.TreeIter? position); + public void move_before (ref Gtk.TreeIter iter, Gtk.TreeIter? position); + [CCode (cname = "gtk_list_store_newv", has_construct_function = false)] + public ListStore.newv ([CCode (array_length_pos = 0.9)] GLib.Type[] types); + public void prepend (out Gtk.TreeIter iter); + public bool remove (Gtk.TreeIter iter); + public void reorder (int new_order); + [CCode (sentinel = "-1")] + public void @set (Gtk.TreeIter iter, ...); + public void set_column_types ([CCode (array_length_pos = 0.9)] GLib.Type[] types); + public void set_valist (Gtk.TreeIter iter, void* var_args); + public void set_value (Gtk.TreeIter iter, int column, GLib.Value value); + public void set_valuesv (Gtk.TreeIter iter, int columns, GLib.Value[] values); + public void swap (Gtk.TreeIter a, Gtk.TreeIter b); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Menu : Gtk.MenuShell, Atk.Implementor, Gtk.Buildable { + public weak Gdk.Window bin_window; + public uint lower_arrow_prelight; + public uint lower_arrow_visible; + public weak Gdk.Region navigation_region; + public uint navigation_timeout; + public uint needs_destruction_ref_count; + public weak Gtk.Widget old_active_menu_item; + public weak Gtk.Widget parent_menu_item; + public weak Gtk.MenuPositionFunc position_func; + public void* position_func_data; + public int saved_scroll_offset; + public uint scroll_fast; + public int scroll_offset; + public int scroll_step; + public uint tearoff_active; + public weak Gtk.Adjustment tearoff_adjustment; + public weak Gtk.Widget tearoff_hbox; + public weak Gtk.Widget tearoff_scrollbar; + public weak Gtk.Widget tearoff_window; + public uint timeout_id; + public uint toggle_size; + public weak Gtk.Widget toplevel; + public uint torn_off; + public uint upper_arrow_prelight; + public uint upper_arrow_visible; + public weak Gdk.Window view_window; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Menu (); + public void attach (Gtk.Widget child, uint left_attach, uint right_attach, uint top_attach, uint bottom_attach); + public void attach_to_widget (Gtk.Widget attach_widget, Gtk.MenuDetachFunc? detacher); + public void detach (); + public unowned Gtk.AccelGroup get_accel_group (); + public unowned string get_accel_path (); + public unowned Gtk.Widget get_active (); + public unowned Gtk.Widget get_attach_widget (); + public static unowned GLib.List get_for_attach_widget (Gtk.Widget widget); + public int get_monitor (); + public bool get_reserve_toggle_size (); + public bool get_tearoff_state (); + public unowned string get_title (); + public void popdown (); + public void popup (Gtk.Widget? parent_menu_shell, Gtk.Widget? parent_menu_item, Gtk.MenuPositionFunc? func, uint button, uint32 activate_time); + public void reorder_child (Gtk.Widget child, int position); + public void reposition (); + public void set_accel_group (Gtk.AccelGroup accel_group); + public void set_accel_path (string accel_path); + public void set_active (uint index_); + public void set_monitor (int monitor_num); + public void set_reserve_toggle_size (bool reserve_toggle_size); + public void set_screen (Gdk.Screen? screen); + public void set_tearoff_state (bool torn_off); + public void set_title (string title); + public Gtk.AccelGroup accel_group { get; set; } + public string accel_path { get; set; } + public int active { get; set; } + [NoAccessorMethod] + public Gtk.Widget attach_widget { owned get; set; } + public int monitor { get; set; } + public bool reserve_toggle_size { get; set; } + public bool tearoff_state { get; set; } + [NoAccessorMethod] + public string tearoff_title { owned get; set; } + public virtual signal void move_scroll (Gtk.ScrollType p0); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class MenuBar : Gtk.MenuShell, Atk.Implementor, Gtk.Buildable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public MenuBar (); + public Gtk.PackDirection get_child_pack_direction (); + public Gtk.PackDirection get_pack_direction (); + public void set_child_pack_direction (Gtk.PackDirection child_pack_dir); + public void set_pack_direction (Gtk.PackDirection pack_dir); + public Gtk.PackDirection child_pack_direction { get; set; } + public Gtk.PackDirection pack_direction { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class MenuItem : Gtk.Item, Atk.Implementor, Gtk.Buildable, Gtk.Activatable { + public uint16 accelerator_width; + public weak Gdk.Window event_window; + public uint from_menubar; + public uint right_justify; + public uint show_submenu_indicator; + public uint submenu_direction; + public uint submenu_placement; + public uint timer; + public uint timer_from_keypress; + public uint16 toggle_size; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public MenuItem (); + public unowned string get_accel_path (); + public virtual unowned string get_label (); + public bool get_right_justified (); + public unowned Gtk.Widget get_submenu (); + public bool get_use_underline (); + public void set_accel_path (string accel_path); + public virtual void set_label (string label); + public void set_right_justified (bool right_justified); + public void set_submenu (Gtk.Widget submenu); + public void set_use_underline (bool setting); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public MenuItem.with_label (string label); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public MenuItem.with_mnemonic (string label); + public string accel_path { get; set; } + public string label { get; set; } + public bool right_justified { get; set; } + public Gtk.Menu submenu { get; set; } + public bool use_underline { get; set; } + [HasEmitter] + public virtual signal void activate (); + public virtual signal void activate_item (); + [HasEmitter] + public virtual signal void toggle_size_allocate (int allocation); + [HasEmitter] + public virtual signal void toggle_size_request (void* requisition); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class MenuShell : Gtk.Container, Atk.Implementor, Gtk.Buildable { + public uint32 activate_time; + public uint active; + public weak Gtk.Widget active_menu_item; + public uint button; + public GLib.List children; + public uint have_grab; + public uint have_xgrab; + public uint ignore_enter; + public uint ignore_leave; + public uint keyboard_mode; + public uint menu_flag; + public weak Gtk.Widget parent_menu_shell; + [CCode (has_construct_function = false)] + protected MenuShell (); + public void activate_item (Gtk.Widget menu_item, bool force_deactivate); + public void append ([CCode (type = "GtkWidget*")] Gtk.MenuItem child); + public void deselect (); + [NoWrapper] + public virtual int get_popup_delay (); + public bool get_take_focus (); + public virtual void insert (Gtk.Widget child, int position); + public void prepend (Gtk.Widget child); + public void select_first (bool search_sensitive); + public virtual void select_item (Gtk.Widget menu_item); + public void set_take_focus (bool take_focus); + public bool take_focus { get; set; } + public virtual signal void activate_current (bool force_hide); + [HasEmitter] + public virtual signal void cancel (); + public virtual signal void cycle_focus (Gtk.DirectionType p0); + [HasEmitter] + public virtual signal void deactivate (); + public virtual signal void move_current (Gtk.MenuDirectionType direction); + public virtual signal bool move_selected (int distance); + public virtual signal void selection_done (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class MenuToolButton : Gtk.ToolButton, Atk.Implementor, Gtk.Buildable, Gtk.Activatable { + [CCode (type = "GtkToolItem*", has_construct_function = false)] + public MenuToolButton (Gtk.Widget? icon_widget, string? label); + [CCode (type = "GtkToolItem*", has_construct_function = false)] + public MenuToolButton.from_stock (string stock_id); + public unowned Gtk.Widget get_menu (); + public void set_arrow_tooltip_markup (string markup); + public void set_arrow_tooltip_text (string text); + public void set_menu (Gtk.Widget menu); + public Gtk.Menu menu { get; set; } + public virtual signal void show_menu (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class MessageDialog : Gtk.Dialog, Atk.Implementor, Gtk.Buildable { + public weak Gtk.Widget label; + [PrintfFormat] + [CCode (type = "GtkWidget*", has_construct_function = false)] + public MessageDialog (Gtk.Window? parent, Gtk.DialogFlags flags, Gtk.MessageType type, Gtk.ButtonsType buttons, string message_format, ...); + public void format_secondary_markup (string message_format, ...); + public void format_secondary_text (string message_format, ...); + public unowned Gtk.Widget get_image (); + public void set_image (Gtk.Widget image); + public void set_markup (string str); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public MessageDialog.with_markup (Gtk.Window? parent, Gtk.DialogFlags flags, Gtk.MessageType type, Gtk.ButtonsType buttons, string message_format, ...); + [NoAccessorMethod] + public Gtk.ButtonsType buttons { construct; } + public Gtk.Widget image { get; set; } + [NoAccessorMethod] + public Gtk.MessageType message_type { get; set construct; } + [NoAccessorMethod] + public string secondary_text { owned get; set; } + [NoAccessorMethod] + public bool secondary_use_markup { get; set; } + [NoAccessorMethod] + public string text { owned get; set; } + [NoAccessorMethod] + public bool use_markup { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Misc : Gtk.Widget, Atk.Implementor, Gtk.Buildable { + [CCode (has_construct_function = false)] + protected Misc (); + public void get_alignment (float xalign, float yalign); + public void get_padding (int xpad, int ypad); + public void set_alignment (float xalign, float yalign); + public void set_padding (int xpad, int ypad); + [NoAccessorMethod] + public float xalign { get; set; } + [NoAccessorMethod] + public int xpad { get; set; } + [NoAccessorMethod] + public float yalign { get; set; } + [NoAccessorMethod] + public int ypad { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class MountOperation : GLib.MountOperation { + [CCode (type = "GMountOperation*", has_construct_function = false)] + public MountOperation (Gtk.Window? parent); + public unowned Gtk.Window get_parent (); + public unowned Gdk.Screen get_screen (); + public void set_parent (Gtk.Window parent); + public void set_screen (Gdk.Screen screen); + [NoAccessorMethod] + public bool is_showing { get; } + public Gtk.Window parent { get; set; } + public Gdk.Screen screen { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Notebook : Gtk.Container, Atk.Implementor, Gtk.Buildable { + public uint button; + public uint child_has_focus; + public weak GLib.List children; + public uint click_child; + public weak Gtk.NotebookPage cur_page; + public weak Gdk.Window event_window; + public weak GLib.List first_tab; + public uint focus_out; + public uint has_after_next; + public uint has_after_previous; + public uint has_before_next; + public uint has_before_previous; + public uint have_visible_child; + public uint in_child; + public weak Gtk.Widget menu; + public uint need_timer; + public uint32 timer; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Notebook (); + public int append_page (Gtk.Widget child, Gtk.Widget? tab_label); + public int append_page_menu (Gtk.Widget child, Gtk.Widget? tab_label, Gtk.Widget? menu_label); + public unowned Gtk.Widget get_action_widget (Gtk.PackType pack_type); + public int get_current_page (); + public void* get_group (); + public unowned Gtk.Widget get_menu_label (Gtk.Widget child); + public unowned string get_menu_label_text (Gtk.Widget child); + public int get_n_pages (); + public unowned Gtk.Widget get_nth_page (int page_num); + public bool get_scrollable (); + public bool get_show_border (); + public bool get_show_tabs (); + public bool get_tab_detachable (Gtk.Widget child); + public unowned Gtk.Widget get_tab_label (Gtk.Widget child); + public unowned string get_tab_label_text (Gtk.Widget child); + public Gtk.PositionType get_tab_pos (); + public bool get_tab_reorderable (Gtk.Widget child); + public int insert_page (Gtk.Widget child, Gtk.Widget? tab_label, int position); + [CCode (vfunc_name = "insert_page")] + public virtual int insert_page_menu (Gtk.Widget child, Gtk.Widget? tab_label, Gtk.Widget? menu_label, int position); + public void next_page (); + public int page_num (Gtk.Widget child); + public void popup_disable (); + public void popup_enable (); + public int prepend_page (Gtk.Widget child, Gtk.Widget? tab_label); + public int prepend_page_menu (Gtk.Widget child, Gtk.Widget? tab_label, Gtk.Widget? menu_label); + public void prev_page (); + public void query_tab_label_packing (Gtk.Widget child, bool? expand, bool? fill, Gtk.PackType? pack_type); + public void remove_page (int page_num); + public void reorder_child (Gtk.Widget child, int position); + public void set_action_widget (Gtk.Widget widget, Gtk.PackType pack_type); + public void set_current_page (int page_num); + public void set_group (void* group); + public void set_menu_label (Gtk.Widget child, Gtk.Widget? menu_label); + public void set_menu_label_text (Gtk.Widget child, string menu_text); + public void set_scrollable (bool scrollable); + public void set_show_border (bool show_border); + public void set_show_tabs (bool show_tabs); + public void set_tab_detachable (Gtk.Widget child, bool detachable); + public void set_tab_label (Gtk.Widget child, Gtk.Widget? tab_label); + public void set_tab_label_packing (Gtk.Widget child, bool expand, bool fill, Gtk.PackType pack_type); + public void set_tab_label_text (Gtk.Widget child, string tab_text); + public void set_tab_pos (Gtk.PositionType pos); + public void set_tab_reorderable (Gtk.Widget child, bool reorderable); + public static void set_window_creation_hook (owned Gtk.NotebookWindowCreationFunc func); + [NoAccessorMethod] + public bool enable_popup { get; set; } + public void* group { get; set; } + [NoAccessorMethod] + public int group_id { get; set; } + [NoAccessorMethod] + public bool homogeneous { get; set; } + [NoAccessorMethod] + public int page { get; set; } + public bool scrollable { get; set; } + public bool show_border { get; set; } + public bool show_tabs { get; set; } + [NoAccessorMethod] + public uint tab_border { set; } + [NoAccessorMethod] + public uint tab_hborder { get; set; } + public Gtk.PositionType tab_pos { get; set; } + [NoAccessorMethod] + public uint tab_vborder { get; set; } + public virtual signal bool change_current_page (int offset); + public virtual signal unowned Gtk.Notebook create_window (Gtk.Widget page, int x, int y); + public virtual signal bool focus_tab (Gtk.NotebookTab type); + public virtual signal void move_focus_out (Gtk.DirectionType direction); + public virtual signal void page_added (Gtk.Widget p0, uint p1); + public virtual signal void page_removed (Gtk.Widget p0, uint p1); + public virtual signal void page_reordered (Gtk.Widget p0, uint p1); + public virtual signal bool reorder_tab (Gtk.DirectionType direction, bool move_to_last); + public virtual signal bool select_page (bool move_focus); + public virtual signal void switch_page (Gtk.NotebookPage page, uint page_num); + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class NotebookPage { + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Object : GLib.InitiallyUnowned { + public uint32 flags; + [CCode (has_construct_function = false)] + protected Object (); + [NoWrapper] + public virtual void get_arg (Gtk.Arg arg, uint arg_id); + [NoWrapper] + public virtual void set_arg (Gtk.Arg arg, uint arg_id); + [NoAccessorMethod] + public void* user_data { get; set; } + [HasEmitter] + public virtual signal void destroy (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class OffscreenWindow : Gtk.Window, Atk.Implementor, Gtk.Buildable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public OffscreenWindow (); + public unowned Gdk.Pixbuf get_pixbuf (); + public unowned Gdk.Pixmap get_pixmap (); + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class PageRange { + public int end; + public int start; + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class PageSetup : GLib.Object { + [CCode (has_construct_function = false)] + public PageSetup (); + public Gtk.PageSetup copy (); + [CCode (has_construct_function = false)] + public PageSetup.from_file (string file_name) throws GLib.Error; + [CCode (has_construct_function = false)] + public PageSetup.from_key_file (GLib.KeyFile key_file, string group_name) throws GLib.Error; + public double get_bottom_margin (Gtk.Unit unit); + public double get_left_margin (Gtk.Unit unit); + public Gtk.PageOrientation get_orientation (); + public double get_page_height (Gtk.Unit unit); + public double get_page_width (Gtk.Unit unit); + public double get_paper_height (Gtk.Unit unit); + public unowned Gtk.PaperSize get_paper_size (); + public double get_paper_width (Gtk.Unit unit); + public double get_right_margin (Gtk.Unit unit); + public double get_top_margin (Gtk.Unit unit); + public bool load_file (string file_name) throws GLib.Error; + public bool load_key_file (GLib.KeyFile key_file, string group_name) throws GLib.Error; + public void set_bottom_margin (double margin, Gtk.Unit unit); + public void set_left_margin (double margin, Gtk.Unit unit); + public void set_orientation (Gtk.PageOrientation orientation); + public void set_paper_size (Gtk.PaperSize size); + public void set_paper_size_and_default_margins (Gtk.PaperSize size); + public void set_right_margin (double margin, Gtk.Unit unit); + public void set_top_margin (double margin, Gtk.Unit unit); + public bool to_file (string file_name) throws GLib.Error; + public void to_key_file (GLib.KeyFile key_file, string group_name); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Paned : Gtk.Container, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + public weak Gtk.Widget child1; + public uint child1_resize; + public uint child1_shrink; + public int child1_size; + public weak Gtk.Widget child2; + public uint child2_resize; + public uint child2_shrink; + public Gdk.CursorType cursor_type; + public int drag_pos; + public weak Gdk.Window handle; + public Gdk.Rectangle handle_pos; + public uint handle_prelit; + public uint in_drag; + public uint in_recursion; + public int last_allocation; + public weak Gtk.Widget last_child1_focus; + public weak Gtk.Widget last_child2_focus; + public uint orientation; + public int original_position; + public weak Gdk.GC xor_gc; + [CCode (has_construct_function = false)] + protected Paned (); + public void add1 (Gtk.Widget child); + public void add2 (Gtk.Widget child); + public unowned Gtk.Widget get_child1 (); + public unowned Gtk.Widget get_child2 (); + public unowned Gdk.Window get_handle_window (); + public int get_position (); + public void pack1 (Gtk.Widget child, bool resize, bool shrink); + public void pack2 (Gtk.Widget child, bool resize, bool shrink); + public void set_position (int position); + [NoAccessorMethod] + public int max_position { get; } + [NoAccessorMethod] + public int min_position { get; } + public int position { get; set; } + [NoAccessorMethod] + public bool position_set { get; set; } + public virtual signal bool accept_position (); + public virtual signal bool cancel_position (); + public virtual signal bool cycle_child_focus (bool reverse); + public virtual signal bool cycle_handle_focus (bool reverse); + public virtual signal bool move_handle (Gtk.ScrollType scroll); + public virtual signal bool toggle_handle_focus (); + } + [Compact] + [CCode (copy_function = "gtk_paper_size_copy", type_id = "GTK_TYPE_PAPER_SIZE", cheader_filename = "gtk/gtk.h")] + public class PaperSize { + [CCode (has_construct_function = false)] + public PaperSize (string name); + public Gtk.PaperSize copy (); + [CCode (has_construct_function = false)] + public PaperSize.custom (string name, string display_name, double width, double height, Gtk.Unit unit); + [CCode (has_construct_function = false)] + public PaperSize.from_key_file (GLib.KeyFile key_file, string group_name) throws GLib.Error; + [CCode (has_construct_function = false)] + public PaperSize.from_ppd (string ppd_name, string ppd_display_name, double width, double height); + public static unowned string get_default (); + public double get_default_bottom_margin (Gtk.Unit unit); + public double get_default_left_margin (Gtk.Unit unit); + public double get_default_right_margin (Gtk.Unit unit); + public double get_default_top_margin (Gtk.Unit unit); + public unowned string get_display_name (); + public double get_height (Gtk.Unit unit); + public unowned string get_name (); + public static GLib.List get_paper_sizes (bool include_custom); + public unowned string get_ppd_name (); + public double get_width (Gtk.Unit unit); + public bool is_custom (); + public bool is_equal (Gtk.PaperSize size2); + public void set_size (double width, double height, Gtk.Unit unit); + public void to_key_file (GLib.KeyFile key_file, string group_name); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Plug : Gtk.Window, Atk.Implementor, Gtk.Buildable { + public weak GLib.HashTable grabbed_keys; + public weak Gtk.WindowGroup modality_group; + public weak Gtk.Widget modality_window; + public uint same_app; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Plug (Gdk.NativeWindow socket_id); + public void @construct (Gdk.NativeWindow socket_id); + public void construct_for_display (Gdk.Display display, Gdk.NativeWindow socket_id); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Plug.for_display (Gdk.Display display, Gdk.NativeWindow socket_id); + public bool get_embedded (); + public Gdk.NativeWindow get_id (); + public unowned Gdk.Window get_socket_window (); + public bool embedded { get; } + public Gdk.Window socket_window { get; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class PrintContext : GLib.Object { + [CCode (has_construct_function = false)] + protected PrintContext (); + public unowned Pango.Context create_pango_context (); + public unowned Pango.Layout create_pango_layout (); + public unowned Cairo.Context get_cairo_context (); + public double get_dpi_x (); + public double get_dpi_y (); + public bool get_hard_margins (double top, double bottom, double left, double right); + public double get_height (); + public unowned Gtk.PageSetup get_page_setup (); + public unowned Pango.FontMap get_pango_fontmap (); + public double get_width (); + public void set_cairo_context (Cairo.Context cr, double dpi_x, double dpi_y); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class PrintOperation : GLib.Object, Gtk.PrintOperationPreview { + [CCode (has_construct_function = false)] + public PrintOperation (); + public void cancel (); + public void draw_page_finish (); + public unowned Gtk.PageSetup get_default_page_setup (); + public bool get_embed_page_setup (); + public void get_error () throws GLib.Error; + public bool get_has_selection (); + public int get_n_pages_to_print (); + public unowned Gtk.PrintSettings get_print_settings (); + public Gtk.PrintStatus get_status (); + public unowned string get_status_string (); + public bool get_support_selection (); + public bool is_finished (); + public Gtk.PrintOperationResult run (Gtk.PrintOperationAction action, Gtk.Window parent) throws GLib.Error; + public void set_allow_async (bool allow_async); + public void set_current_page (int current_page); + public void set_custom_tab_label (string label); + public void set_default_page_setup (Gtk.PageSetup default_page_setup); + public void set_defer_drawing (); + public void set_embed_page_setup (bool embed); + public void set_export_filename (string filename); + public void set_has_selection (bool has_selection); + public void set_job_name (string job_name); + public void set_n_pages (int n_pages); + public void set_print_settings (Gtk.PrintSettings print_settings); + public void set_show_progress (bool show_progress); + public void set_support_selection (bool support_selection); + public void set_track_print_status (bool track_status); + public void set_unit (Gtk.Unit unit); + public void set_use_full_page (bool full_page); + [NoAccessorMethod] + public bool allow_async { get; set; } + [NoAccessorMethod] + public int current_page { get; set; } + [NoAccessorMethod] + public string custom_tab_label { owned get; set; } + public Gtk.PageSetup default_page_setup { get; set; } + public bool embed_page_setup { get; set; } + [NoAccessorMethod] + public string export_filename { owned get; set; } + public bool has_selection { get; set; } + [NoAccessorMethod] + public string job_name { owned get; set; } + [NoAccessorMethod] + public int n_pages { get; set; } + public int n_pages_to_print { get; } + public Gtk.PrintSettings print_settings { get; set; } + [NoAccessorMethod] + public bool show_progress { get; set; } + public Gtk.PrintStatus status { get; } + public string status_string { get; } + public bool support_selection { get; set; } + [NoAccessorMethod] + public bool track_print_status { get; set; } + [NoAccessorMethod] + public Gtk.Unit unit { get; set; } + [NoAccessorMethod] + public bool use_full_page { get; set; } + public virtual signal void begin_print (Gtk.PrintContext context); + public virtual signal unowned GLib.Object create_custom_widget (); + public virtual signal void custom_widget_apply (Gtk.Widget widget); + public virtual signal void done (Gtk.PrintOperationResult result); + public virtual signal void draw_page (Gtk.PrintContext context, int page_nr); + public virtual signal void end_print (Gtk.PrintContext context); + public virtual signal bool paginate (Gtk.PrintContext context); + public virtual signal bool preview (Gtk.PrintOperationPreview preview, Gtk.PrintContext context, Gtk.Window parent); + public virtual signal void request_page_setup (Gtk.PrintContext context, int page_nr, Gtk.PageSetup setup); + public virtual signal void status_changed (); + public virtual signal void update_custom_widget (Gtk.Widget widget, Gtk.PageSetup setup, Gtk.PrintSettings settings); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class PrintSettings : GLib.Object { + [CCode (has_construct_function = false)] + public PrintSettings (); + public Gtk.PrintSettings copy (); + public void @foreach (Gtk.PrintSettingsFunc func); + [CCode (has_construct_function = false)] + public PrintSettings.from_file (string file_name) throws GLib.Error; + [CCode (has_construct_function = false)] + public PrintSettings.from_key_file (GLib.KeyFile key_file, string group_name) throws GLib.Error; + public unowned string @get (string key); + public bool get_bool (string key); + public bool get_collate (); + public unowned string get_default_source (); + public unowned string get_dither (); + public double get_double (string key); + public double get_double_with_default (string key, double def); + public Gtk.PrintDuplex get_duplex (); + public unowned string get_finishings (); + public int get_int (string key); + public int get_int_with_default (string key, int def); + public double get_length (string key, Gtk.Unit unit); + public unowned string get_media_type (); + public int get_n_copies (); + public int get_number_up (); + public Gtk.NumberUpLayout get_number_up_layout (); + public Gtk.PageOrientation get_orientation (); + public unowned string get_output_bin (); + public unowned Gtk.PageRange get_page_ranges (int num_ranges); + public Gtk.PageSet get_page_set (); + public double get_paper_height (Gtk.Unit unit); + public unowned Gtk.PaperSize get_paper_size (); + public double get_paper_width (Gtk.Unit unit); + public Gtk.PrintPages get_print_pages (); + public unowned string get_printer (); + public double get_printer_lpi (); + public Gtk.PrintQuality get_quality (); + public int get_resolution (); + public int get_resolution_x (); + public int get_resolution_y (); + public bool get_reverse (); + public double get_scale (); + public bool get_use_color (); + public bool has_key (string key); + public bool load_file (string file_name) throws GLib.Error; + public bool load_key_file (GLib.KeyFile key_file, string group_name) throws GLib.Error; + public void @set (string key, string value); + public void set_bool (string key, bool value); + public void set_collate (bool collate); + public void set_default_source (string default_source); + public void set_dither (string dither); + public void set_double (string key, double value); + public void set_duplex (Gtk.PrintDuplex duplex); + public void set_finishings (string finishings); + public void set_int (string key, int value); + public void set_length (string key, double value, Gtk.Unit unit); + public void set_media_type (string media_type); + public void set_n_copies (int num_copies); + public void set_number_up (int number_up); + public void set_number_up_layout (Gtk.NumberUpLayout number_up_layout); + public void set_orientation (Gtk.PageOrientation orientation); + public void set_output_bin (string output_bin); + public void set_page_ranges (Gtk.PageRange page_ranges, int num_ranges); + public void set_page_set (Gtk.PageSet page_set); + public void set_paper_height (double height, Gtk.Unit unit); + public void set_paper_size (Gtk.PaperSize paper_size); + public void set_paper_width (double width, Gtk.Unit unit); + public void set_print_pages (Gtk.PrintPages pages); + public void set_printer (string printer); + public void set_printer_lpi (double lpi); + public void set_quality (Gtk.PrintQuality quality); + public void set_resolution (int resolution); + public void set_resolution_xy (int resolution_x, int resolution_y); + public void set_reverse (bool reverse); + public void set_scale (double scale); + public void set_use_color (bool use_color); + public bool to_file (string file_name) throws GLib.Error; + public void to_key_file (GLib.KeyFile key_file, string group_name); + public void unset (string key); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class ProgressBar : Gtk.Widget, Atk.Implementor, Gtk.Buildable { + public uint activity_dir; + public int activity_pos; + public uint blocks; + public uint dirty; + public int in_block; + public double pulse_fraction; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public ProgressBar (); + public Pango.EllipsizeMode get_ellipsize (); + public double get_fraction (); + public Gtk.ProgressBarOrientation get_orientation (); + public double get_pulse_step (); + public unowned string get_text (); + public void pulse (); + public void set_ellipsize (Pango.EllipsizeMode mode); + public void set_fraction (double fraction); + public void set_orientation (Gtk.ProgressBarOrientation orientation); + public void set_pulse_step (double fraction); + public void set_text (string text); + [NoAccessorMethod] + public uint activity_blocks { get; set; } + [NoAccessorMethod] + public uint activity_step { get; set; } + [NoAccessorMethod] + public Gtk.Adjustment adjustment { owned get; set; } + [NoAccessorMethod] + public Gtk.ProgressBarStyle bar_style { get; set; } + [NoAccessorMethod] + public uint discrete_blocks { get; set; } + public Pango.EllipsizeMode ellipsize { get; set; } + public double fraction { get; set; } + public Gtk.ProgressBarOrientation orientation { get; set; } + public double pulse_step { get; set; } + public string text { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class RadioAction : Gtk.ToggleAction, Gtk.Buildable { + [CCode (has_construct_function = false)] + public RadioAction (string name, string? label, string? tooltip, string? stock_id, int value); + public int get_current_value (); + public unowned GLib.SList get_group (); + public void set_current_value (int current_value); + public void set_group (GLib.SList group); + public int current_value { get; set; } + [NoAccessorMethod] + public Gtk.RadioAction group { set; } + [NoAccessorMethod] + public int value { get; set; } + public virtual signal void changed (Gtk.RadioAction current); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class RadioButton : Gtk.CheckButton, Atk.Implementor, Gtk.Buildable, Gtk.Activatable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public RadioButton (GLib.SList? group); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public RadioButton.from_widget (Gtk.RadioButton radio_group_member); + public unowned GLib.SList get_group (); + public void set_group (GLib.SList group); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public RadioButton.with_label (GLib.SList? group, string label); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public RadioButton.with_label_from_widget (Gtk.RadioButton radio_group_member, string label); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public RadioButton.with_mnemonic (GLib.SList? group, string label); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public RadioButton.with_mnemonic_from_widget (Gtk.RadioButton radio_group_member, string label); + [NoAccessorMethod] + public Gtk.RadioButton group { set; } + public virtual signal void group_changed (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class RadioMenuItem : Gtk.CheckMenuItem, Atk.Implementor, Gtk.Buildable, Gtk.Activatable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public RadioMenuItem (GLib.SList group); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public RadioMenuItem.from_widget (Gtk.RadioMenuItem group); + public unowned GLib.SList get_group (); + public void set_group (GLib.SList group); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public RadioMenuItem.with_label (GLib.SList group, string label); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public RadioMenuItem.with_label_from_widget (Gtk.RadioMenuItem group, string label); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public RadioMenuItem.with_mnemonic (GLib.SList group, string label); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public RadioMenuItem.with_mnemonic_from_widget (Gtk.RadioMenuItem group, string label); + public Gtk.RadioMenuItem group { set; } + public virtual signal void group_changed (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class RadioToolButton : Gtk.ToggleToolButton, Atk.Implementor, Gtk.Buildable, Gtk.Activatable { + [CCode (type = "GtkToolItem*", has_construct_function = false)] + public RadioToolButton (GLib.SList? group); + [CCode (type = "GtkToolItem*", has_construct_function = false)] + public RadioToolButton.from_stock (GLib.SList? group, string stock_id); + [CCode (type = "GtkToolItem*", has_construct_function = false)] + public RadioToolButton.from_widget (Gtk.RadioToolButton group); + public unowned GLib.SList get_group (); + public void set_group (GLib.SList group); + [CCode (type = "GtkToolItem*", has_construct_function = false)] + public RadioToolButton.with_stock_from_widget (Gtk.RadioToolButton group, string stock_id); + public Gtk.RadioToolButton group { set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Range : Gtk.Widget, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + public weak Gdk.Window event_window; + public uint flippable; + public uint has_stepper_a; + public uint has_stepper_b; + public uint has_stepper_c; + public uint has_stepper_d; + public weak Gtk.RangeLayout layout; + public int min_slider_size; + public uint need_recalc; + public Gtk.Orientation orientation; + public Gdk.Rectangle range_rect; + public int round_digits; + public int slide_initial_coordinate; + public int slide_initial_slider_position; + public int slider_end; + public uint slider_size_fixed; + public int slider_start; + public weak Gtk.RangeStepTimer timer; + public uint trough_click_forward; + public uint update_pending; + public uint update_timeout_id; + [CCode (has_construct_function = false)] + protected Range (); + public unowned Gtk.Adjustment get_adjustment (); + public double get_fill_level (); + public bool get_flippable (); + public bool get_inverted (); + public Gtk.SensitivityType get_lower_stepper_sensitivity (); + public int get_min_slider_size (); + [NoWrapper] + public virtual void get_range_border (Gtk.Border border_); + public void get_range_rect (Gdk.Rectangle range_rect); + public bool get_restrict_to_fill_level (); + public bool get_show_fill_level (); + public void get_slider_range (out int slider_start, out int slider_end); + public bool get_slider_size_fixed (); + public Gtk.UpdateType get_update_policy (); + public Gtk.SensitivityType get_upper_stepper_sensitivity (); + public double get_value (); + public void set_adjustment (Gtk.Adjustment adjustment); + public void set_fill_level (double fill_level); + public void set_flippable (bool flippable); + public void set_increments (double step, double page); + public void set_inverted (bool setting); + public void set_lower_stepper_sensitivity (Gtk.SensitivityType sensitivity); + public void set_min_slider_size (bool min_size); + public void set_range (double min, double max); + public void set_restrict_to_fill_level (bool restrict_to_fill_level); + public void set_show_fill_level (bool show_fill_level); + public void set_slider_size_fixed (bool size_fixed); + public void set_update_policy (Gtk.UpdateType policy); + public void set_upper_stepper_sensitivity (Gtk.SensitivityType sensitivity); + public void set_value (double value); + public Gtk.Adjustment adjustment { get; set construct; } + public double fill_level { get; set; } + public bool inverted { get; set; } + public Gtk.SensitivityType lower_stepper_sensitivity { get; set; } + public bool restrict_to_fill_level { get; set; } + public bool show_fill_level { get; set; } + public Gtk.UpdateType update_policy { get; set; } + public Gtk.SensitivityType upper_stepper_sensitivity { get; set; } + public virtual signal void adjust_bounds (double new_value); + public virtual signal bool change_value (Gtk.ScrollType scroll, double new_value); + public virtual signal void move_slider (Gtk.ScrollType scroll); + public virtual signal void value_changed (); + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class RangeLayout { + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class RangeStepTimer { + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class RcContext { + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class RcProperty { + public weak string origin; + public GLib.Quark property_name; + public GLib.Quark type_name; + public GLib.Value value; + public static bool parse_border (GLib.ParamSpec pspec, GLib.StringBuilder gstring, GLib.Value property_value); + public static bool parse_color (GLib.ParamSpec pspec, GLib.StringBuilder gstring, GLib.Value property_value); + public static bool parse_enum (GLib.ParamSpec pspec, GLib.StringBuilder gstring, GLib.Value property_value); + public static bool parse_flags (GLib.ParamSpec pspec, GLib.StringBuilder gstring, GLib.Value property_value); + public static bool parse_requisition (GLib.ParamSpec pspec, GLib.StringBuilder gstring, GLib.Value property_value); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class RcStyle : GLib.Object { + [CCode (array_length = false)] + public weak Gdk.Color[] @base; + [CCode (array_length = false)] + public weak Gdk.Color[] bg; + [CCode (array_length = false)] + public weak string[] bg_pixmap_name; + [CCode (array_length = false)] + public weak Gtk.RcFlags[] color_flags; + public uint engine_specified; + [CCode (array_length = false)] + public weak Gdk.Color[] fg; + public weak Pango.FontDescription font_desc; + public weak GLib.SList icon_factories; + public weak string name; + public weak GLib.Array rc_properties; + public weak GLib.SList rc_style_lists; + [CCode (array_length = false)] + public weak Gdk.Color[] text; + public int xthickness; + public int ythickness; + [CCode (has_construct_function = false)] + public RcStyle (); + public Gtk.RcStyle copy (); + [NoWrapper] + public virtual unowned Gtk.RcStyle create_rc_style (); + [NoWrapper] + public virtual Gtk.Style create_style (); + [NoWrapper] + public virtual void merge (Gtk.RcStyle src); + [NoWrapper] + public virtual uint parse (Gtk.Settings settings, GLib.Scanner scanner); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class RecentAction : Gtk.Action, Gtk.Buildable, Gtk.RecentChooser { + [CCode (type = "GtkAction*", has_construct_function = false)] + public RecentAction (string name, string label, string tooltip, string stock_id); + [CCode (type = "GtkAction*", has_construct_function = false)] + public RecentAction.for_manager (string name, string label, string tooltip, string stock_id, Gtk.RecentManager manager); + public bool get_show_numbers (); + public void set_show_numbers (bool show_numbers); + public bool show_numbers { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class RecentChooserDialog : Gtk.Dialog, Atk.Implementor, Gtk.Buildable, Gtk.RecentChooser { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public RecentChooserDialog (string title, Gtk.Window parent, ...); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public RecentChooserDialog.for_manager (string title, Gtk.Window parent, Gtk.RecentManager manager, ...); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class RecentChooserMenu : Gtk.Menu, Atk.Implementor, Gtk.Buildable, Gtk.Activatable, Gtk.RecentChooser { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public RecentChooserMenu (); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public RecentChooserMenu.for_manager (Gtk.RecentManager manager); + public bool get_show_numbers (); + [NoWrapper] + public virtual void gtk_recent1 (); + [NoWrapper] + public virtual void gtk_recent2 (); + [NoWrapper] + public virtual void gtk_recent3 (); + [NoWrapper] + public virtual void gtk_recent4 (); + public void set_show_numbers (bool show_numbers); + public bool show_numbers { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class RecentChooserWidget : Gtk.VBox, Atk.Implementor, Gtk.Buildable, Gtk.Orientable, Gtk.RecentChooser { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public RecentChooserWidget (); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public RecentChooserWidget.for_manager (Gtk.RecentManager manager); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class RecentFilter : Gtk.Object { + [CCode (has_construct_function = false)] + public RecentFilter (); + public void add_age (int days); + public void add_application (string application); + public void add_custom (Gtk.RecentFilterFlags needed, owned Gtk.RecentFilterFunc func); + public void add_group (string group); + public void add_mime_type (string mime_type); + public void add_pattern (string pattern); + public void add_pixbuf_formats (); + public bool filter (Gtk.RecentFilterInfo filter_info); + public unowned string get_name (); + public Gtk.RecentFilterFlags get_needed (); + public void set_name (string name); + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class RecentFilterInfo { + public int age; + public weak string applications; + public Gtk.RecentFilterFlags contains; + public weak string display_name; + public weak string groups; + public weak string mime_type; + public weak string uri; + } + [Compact] + [CCode (ref_function = "gtk_recent_info_ref", unref_function = "gtk_recent_info_unref", type_id = "GTK_TYPE_RECENT_INFO", cheader_filename = "gtk/gtk.h")] + public class RecentInfo { + public bool exists (); + public ulong get_added (); + public int get_age (); + public bool get_application_info (string app_name, out unowned string app_exec, out uint count, out ulong time_); + [CCode (array_length_type = "gsize")] + public string[] get_applications (); + public unowned string get_description (); + public unowned string get_display_name (); + [CCode (array_length_type = "gsize")] + public string[] get_groups (); + public Gdk.Pixbuf? get_icon (int size); + public unowned string get_mime_type (); + public ulong get_modified (); + public bool get_private_hint (); + public string get_short_name (); + public unowned string get_uri (); + public string? get_uri_display (); + public ulong get_visited (); + public bool has_application (string app_name); + public bool has_group (string group_name); + public bool is_local (); + public string last_application (); + public bool match (Gtk.RecentInfo info_b); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class RecentManager : GLib.Object { + [CCode (has_construct_function = false)] + public RecentManager (); + public bool add_full (string uri, Gtk.RecentData recent_data); + public bool add_item (string uri); + public static GLib.Quark error_quark (); + public static unowned Gtk.RecentManager get_default (); + public GLib.List get_items (); + public int get_limit (); + public bool has_item (string uri); + public unowned Gtk.RecentInfo lookup_item (string uri) throws GLib.Error; + public bool move_item (string uri, string new_uri) throws GLib.Error; + public int purge_items () throws GLib.Error; + public bool remove_item (string uri) throws GLib.Error; + public void set_limit (int limit); + [NoAccessorMethod] + public string filename { owned get; construct; } + public int limit { get; set; } + [NoAccessorMethod] + public int size { get; } + public virtual signal void changed (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Ruler : Gtk.Widget, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + public weak Gdk.Pixmap backing_store; + public weak Gdk.GC non_gr_exp_gc; + public int slider_size; + public int xsrc; + public int ysrc; + [CCode (has_construct_function = false)] + protected Ruler (); + public virtual void draw_pos (); + public virtual void draw_ticks (); + public Gtk.MetricType get_metric (); + public void get_range (double lower, double upper, double position, double max_size); + public void set_metric (Gtk.MetricType metric); + public void set_range (double lower, double upper, double position, double max_size); + [NoAccessorMethod] + public double lower { get; set; } + [NoAccessorMethod] + public double max_size { get; set; } + public Gtk.MetricType metric { get; set; } + [NoAccessorMethod] + public double position { get; set; } + [NoAccessorMethod] + public double upper { get; set; } + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class RulerMetric { + public weak string abbrev; + public weak string metric_name; + public double pixels_per_unit; + [CCode (array_length = false)] + public weak double[] ruler_scale; + [CCode (array_length = false)] + public weak int[] subdivide; + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Scale : Gtk.Range, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + [CCode (has_construct_function = false)] + protected Scale (); + public void add_mark (double value, Gtk.PositionType position, string? markup); + public void clear_marks (); + public int get_digits (); + public bool get_draw_value (); + public unowned Pango.Layout get_layout (); + public virtual void get_layout_offsets (out int x, out int y); + public Gtk.PositionType get_value_pos (); + public void set_digits (int digits); + public void set_draw_value (bool draw_value); + public void set_value_pos (Gtk.PositionType pos); + public int digits { get; set; } + public bool draw_value { get; set; } + public Gtk.PositionType value_pos { get; set; } + public virtual signal string format_value (double value); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class ScaleButton : Gtk.Button, Atk.Implementor, Gtk.Buildable, Gtk.Orientable, Gtk.Activatable { + public weak Gtk.Widget minus_button; + public weak Gtk.Widget plus_button; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public ScaleButton (Gtk.IconSize size, double min, double max, double step, [CCode (array_length = false)] string[] icons); + public unowned Gtk.Adjustment get_adjustment (); + public unowned Gtk.Widget get_minus_button (); + public unowned Gtk.Widget get_plus_button (); + public unowned Gtk.Widget get_popup (); + public double get_value (); + public void set_adjustment (Gtk.Adjustment adjustment); + public void set_icons ([CCode (array_length = false)] string[] icons); + public void set_value (double value); + public Gtk.Adjustment adjustment { get; set; } + [NoAccessorMethod] + [CCode (array_length = false, array_null_terminated = true)] + public string[] icons { owned get; set; } + [NoAccessorMethod] + public Gtk.IconSize size { get; set; } + public double value { get; set; } + public virtual signal void popdown (); + public virtual signal void popup (); + public virtual signal void value_changed (double value); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Scrollbar : Gtk.Range, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + [CCode (has_construct_function = false)] + protected Scrollbar (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class ScrolledWindow : Gtk.Bin, Atk.Implementor, Gtk.Buildable { + public uint focus_out; + public weak Gtk.Widget hscrollbar; + public uint hscrollbar_visible; + public weak Gtk.Widget vscrollbar; + public uint vscrollbar_visible; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public ScrolledWindow (Gtk.Adjustment? hadjustment, Gtk.Adjustment? vadjustment); + public void add_with_viewport (Gtk.Widget child); + public unowned Gtk.Adjustment get_hadjustment (); + public unowned Gtk.Widget get_hscrollbar (); + public Gtk.CornerType get_placement (); + public void get_policy (Gtk.PolicyType hscrollbar_policy, Gtk.PolicyType vscrollbar_policy); + public Gtk.ShadowType get_shadow_type (); + public unowned Gtk.Adjustment get_vadjustment (); + public unowned Gtk.Widget get_vscrollbar (); + public void set_hadjustment (Gtk.Adjustment hadjustment); + public void set_placement (Gtk.CornerType window_placement); + public void set_policy (Gtk.PolicyType hscrollbar_policy, Gtk.PolicyType vscrollbar_policy); + public void set_shadow_type (Gtk.ShadowType type); + public void set_vadjustment (Gtk.Adjustment vadjustment); + public void unset_placement (); + public Gtk.Adjustment hadjustment { get; set construct; } + [NoAccessorMethod] + public Gtk.PolicyType hscrollbar_policy { get; set; } + public Gtk.ShadowType shadow_type { get; set; } + public Gtk.Adjustment vadjustment { get; set construct; } + [NoAccessorMethod] + public Gtk.PolicyType vscrollbar_policy { get; set; } + [NoAccessorMethod] + public Gtk.CornerType window_placement { get; set; } + [NoAccessorMethod] + public bool window_placement_set { get; set; } + public virtual signal void move_focus_out (Gtk.DirectionType direction); + public virtual signal bool scroll_child (Gtk.ScrollType scroll, bool horizontal); + } + [Compact] + [CCode (copy_function = "gtk_selection_data_copy", type_id = "GTK_TYPE_SELECTION_DATA", cheader_filename = "gtk/gtk.h")] + public class SelectionData { + [CCode (array_length = false)] + public weak uchar[] data; + public weak Gdk.Display display; + public int format; + public int length; + public Gdk.Atom selection; + public Gdk.Atom target; + public Gdk.Atom type; + public Gtk.SelectionData copy (); + [CCode (array_length = false)] + public unowned uchar[] get_data (); + public Gdk.Atom get_data_type (); + public unowned Gdk.Display get_display (); + public int get_format (); + public int get_length (); + public Gdk.Pixbuf? get_pixbuf (); + public Gdk.Atom get_selection (); + public Gdk.Atom get_target (); + public bool get_targets (out Gdk.Atom targets, int n_atoms); + public string? get_text (); + [CCode (array_length = false, array_null_terminated = true)] + public string[] get_uris (); + public void @set (Gdk.Atom type, int format, uchar[] data); + public bool set_pixbuf (Gdk.Pixbuf pixbuf); + public bool set_text (string str, int len); + public bool set_uris ([CCode (array_length = false)] string[] uris); + public bool targets_include_image (bool writable); + public bool targets_include_rich_text (Gtk.TextBuffer buffer); + public bool targets_include_text (); + public bool targets_include_uri (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Separator : Gtk.Widget, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + [CCode (has_construct_function = false)] + protected Separator (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class SeparatorMenuItem : Gtk.MenuItem, Atk.Implementor, Gtk.Buildable, Gtk.Activatable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public SeparatorMenuItem (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class SeparatorToolItem : Gtk.ToolItem, Atk.Implementor, Gtk.Buildable, Gtk.Activatable { + [CCode (type = "GtkToolItem*", has_construct_function = false)] + public SeparatorToolItem (); + public bool get_draw (); + public void set_draw (bool draw); + public bool draw { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Settings : GLib.Object { + public weak Gtk.SettingsPropertyValue property_values; + public weak Gtk.RcContext rc_context; + public weak Gdk.Screen screen; + [CCode (has_construct_function = false)] + protected Settings (); + public static unowned Gtk.Settings get_default (); + public static unowned Gtk.Settings get_for_screen (Gdk.Screen screen); + public static void install_property (GLib.ParamSpec pspec); + public static void install_property_parser (GLib.ParamSpec pspec, Gtk.RcPropertyParser parser); + public void set_double_property (string name, double v_double, string origin); + public void set_long_property (string name, long v_long, string origin); + public void set_property_value (string name, Gtk.SettingsValue svalue); + public void set_string_property (string name, string v_string, string origin); + [NoAccessorMethod] + public GLib.HashTable color_hash { owned get; } + [NoAccessorMethod] + public bool gtk_alternative_button_order { get; set; } + [NoAccessorMethod] + public bool gtk_alternative_sort_arrows { get; set; } + [NoAccessorMethod] + public bool gtk_auto_mnemonics { get; set; } + [NoAccessorMethod] + public string gtk_color_scheme { owned get; set; } + [NoAccessorMethod] + public bool gtk_cursor_blink { get; set; } + [NoAccessorMethod] + public int gtk_cursor_blink_time { get; set; } + [NoAccessorMethod] + public int gtk_cursor_blink_timeout { get; set; } + [NoAccessorMethod] + public string gtk_cursor_theme_name { owned get; set; } + [NoAccessorMethod] + public int gtk_cursor_theme_size { get; set; } + [NoAccessorMethod] + public int gtk_dnd_drag_threshold { get; set; } + [NoAccessorMethod] + public int gtk_double_click_distance { get; set; } + [NoAccessorMethod] + public int gtk_double_click_time { get; set; } + [NoAccessorMethod] + public bool gtk_enable_accels { get; set; } + [NoAccessorMethod] + public bool gtk_enable_animations { get; set; } + [NoAccessorMethod] + public bool gtk_enable_event_sounds { get; set; } + [NoAccessorMethod] + public bool gtk_enable_input_feedback_sounds { get; set; } + [NoAccessorMethod] + public bool gtk_enable_mnemonics { get; set; } + [NoAccessorMethod] + public bool gtk_enable_tooltips { get; set; } + [NoAccessorMethod] + public bool gtk_error_bell { get; set; } + [NoAccessorMethod] + public string gtk_fallback_icon_theme { owned get; set; } + [NoAccessorMethod] + public string gtk_file_chooser_backend { owned get; set; } + [NoAccessorMethod] + public string gtk_font_name { owned get; set; } + [NoAccessorMethod] + public uint gtk_fontconfig_timestamp { get; set; } + [NoAccessorMethod] + public string gtk_icon_sizes { owned get; set; } + [NoAccessorMethod] + public string gtk_icon_theme_name { owned get; set; } + [NoAccessorMethod] + public string gtk_im_module { owned get; set; } + [NoAccessorMethod] + public string gtk_key_theme_name { owned get; set; } + [NoAccessorMethod] + public bool gtk_keynav_cursor_only { get; set; } + [NoAccessorMethod] + public bool gtk_keynav_wrap_around { get; set; } + [NoAccessorMethod] + public string gtk_menu_bar_accel { owned get; set; } + [NoAccessorMethod] + public string gtk_modules { owned get; set; } + [NoAccessorMethod] + public string gtk_print_backends { owned get; set; } + [NoAccessorMethod] + public string gtk_print_preview_command { owned get; set; } + [NoAccessorMethod] + public int gtk_recent_files_limit { get; set; } + [NoAccessorMethod] + public int gtk_recent_files_max_age { get; set; } + [NoAccessorMethod] + public bool gtk_show_input_method_menu { get; set; } + [NoAccessorMethod] + public bool gtk_show_unicode_menu { get; set; } + [NoAccessorMethod] + public string gtk_sound_theme_name { owned get; set; } + [NoAccessorMethod] + public bool gtk_split_cursor { get; set; } + [NoAccessorMethod] + public string gtk_theme_name { owned get; set; } + [NoAccessorMethod] + public int gtk_timeout_expand { get; set; } + [NoAccessorMethod] + public int gtk_timeout_initial { get; set; } + [NoAccessorMethod] + public int gtk_timeout_repeat { get; set; } + [NoAccessorMethod] + public Gtk.IconSize gtk_toolbar_icon_size { get; set; } + [NoAccessorMethod] + public Gtk.ToolbarStyle gtk_toolbar_style { get; set; } + [NoAccessorMethod] + public int gtk_tooltip_browse_mode_timeout { get; set; } + [NoAccessorMethod] + public int gtk_tooltip_browse_timeout { get; set; } + [NoAccessorMethod] + public int gtk_tooltip_timeout { get; set; } + [NoAccessorMethod] + public bool gtk_touchscreen_mode { get; set; } + [NoAccessorMethod] + public int gtk_xft_antialias { get; set; } + [NoAccessorMethod] + public int gtk_xft_dpi { get; set; } + [NoAccessorMethod] + public int gtk_xft_hinting { get; set; } + [NoAccessorMethod] + public string gtk_xft_hintstyle { owned get; set; } + [NoAccessorMethod] + public string gtk_xft_rgba { owned get; set; } + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class SettingsPropertyValue { + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class SettingsValue { + public weak string origin; + public GLib.Value value; + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class SizeGroup : GLib.Object, Gtk.Buildable { + public uint have_height; + public uint have_width; + public Gtk.Requisition requisition; + public weak GLib.SList widgets; + [CCode (has_construct_function = false)] + public SizeGroup (Gtk.SizeGroupMode mode); + public void add_widget (Gtk.Widget widget); + public bool get_ignore_hidden (); + public Gtk.SizeGroupMode get_mode (); + public unowned GLib.SList get_widgets (); + public void remove_widget (Gtk.Widget widget); + public void set_ignore_hidden (bool ignore_hidden); + public void set_mode (Gtk.SizeGroupMode mode); + public bool ignore_hidden { get; set; } + public Gtk.SizeGroupMode mode { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Socket : Gtk.Container, Atk.Implementor, Gtk.Buildable { + public weak Gtk.AccelGroup accel_group; + public uint active; + public uint16 current_height; + public uint16 current_width; + public uint focus_in; + public uint have_size; + public uint is_mapped; + public uint need_map; + public weak Gtk.Widget plug_widget; + public weak Gdk.Window plug_window; + public uint16 request_height; + public uint16 request_width; + public uint same_app; + public weak Gtk.Widget toplevel; + public short xembed_version; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Socket (); + public void add_id (Gdk.NativeWindow window_id); + public Gdk.NativeWindow get_id (); + public unowned Gdk.Window get_plug_window (); + public virtual signal void plug_added (); + public virtual signal bool plug_removed (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class SpinButton : Gtk.Entry, Atk.Implementor, Gtk.Buildable, Gtk.CellEditable, Gtk.Editable { + public uint button; + public uint click_child; + public uint in_child; + public uint need_timer; + public weak Gdk.Window panel; + public uint32 timer; + public uint timer_calls; + public double timer_step; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public SpinButton (Gtk.Adjustment adjustment, double climb_rate, uint digits); + public void configure (Gtk.Adjustment adjustment, double climb_rate, uint digits); + public unowned Gtk.Adjustment get_adjustment (); + public uint get_digits (); + public void get_increments (double step, double page); + public bool get_numeric (); + public void get_range (out double min, out double max); + public bool get_snap_to_ticks (); + public Gtk.SpinButtonUpdatePolicy get_update_policy (); + public double get_value (); + public int get_value_as_int (); + public bool get_wrap (); + public void set_adjustment (Gtk.Adjustment adjustment); + public void set_digits (uint digits); + public void set_increments (double step, double page); + public void set_numeric (bool numeric); + public void set_range (double min, double max); + public void set_snap_to_ticks (bool snap_to_ticks); + public void set_update_policy (Gtk.SpinButtonUpdatePolicy policy); + public void set_value (double value); + public void set_wrap (bool wrap); + public void spin (Gtk.SpinType direction, double increment); + public void update (); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public SpinButton.with_range (double min, double max, double step); + public Gtk.Adjustment adjustment { get; set; } + [NoAccessorMethod] + public double climb_rate { get; set; } + public uint digits { get; set; } + public bool numeric { get; set; } + public bool snap_to_ticks { get; set; } + public Gtk.SpinButtonUpdatePolicy update_policy { get; set; } + public double value { get; set; } + public bool wrap { get; set; } + public virtual signal void change_value (Gtk.ScrollType scroll); + public virtual signal int input (void* new_value); + public virtual signal bool output (); + public virtual signal void value_changed (); + public virtual signal void wrapped (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Spinner : Gtk.DrawingArea, Atk.Implementor, Gtk.Buildable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Spinner (); + public void start (); + public void stop (); + [NoAccessorMethod] + public bool active { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class StatusIcon : GLib.Object { + [CCode (has_construct_function = false)] + public StatusIcon (); + [CCode (has_construct_function = false)] + public StatusIcon.from_file (string filename); + [CCode (has_construct_function = false)] + public StatusIcon.from_gicon (GLib.Icon icon); + [CCode (has_construct_function = false)] + public StatusIcon.from_icon_name (string icon_name); + [CCode (has_construct_function = false)] + public StatusIcon.from_pixbuf (Gdk.Pixbuf pixbuf); + [CCode (has_construct_function = false)] + public StatusIcon.from_stock (string stock_id); + public bool get_blinking (); + public bool get_geometry (out unowned Gdk.Screen screen, out Gdk.Rectangle area, out Gtk.Orientation orientation); + public unowned GLib.Icon get_gicon (); + public bool get_has_tooltip (); + public unowned string get_icon_name (); + public unowned Gdk.Pixbuf get_pixbuf (); + public unowned Gdk.Screen get_screen (); + public int get_size (); + public unowned string get_stock (); + public Gtk.ImageType get_storage_type (); + public unowned string get_title (); + public unowned string get_tooltip_markup (); + public unowned string get_tooltip_text (); + public bool get_visible (); + public uint32 get_x11_window_id (); + public bool is_embedded (); + [CCode (instance_pos = -1)] + public void position_menu (Gtk.Menu menu, out int x, out int y, out bool push_in); + public void set_blinking (bool blinking); + public void set_from_file (string filename); + public void set_from_gicon (GLib.Icon icon); + public void set_from_icon_name (string icon_name); + public void set_from_pixbuf (Gdk.Pixbuf pixbuf); + public void set_from_stock (string stock_id); + public void set_has_tooltip (bool has_tooltip); + public void set_name (string name); + public void set_screen (Gdk.Screen screen); + public void set_title (string title); + public void set_tooltip_markup (string markup); + public void set_tooltip_text (string text); + public void set_visible (bool visible); + public bool blinking { get; set; } + [NoAccessorMethod] + public bool embedded { get; } + [NoAccessorMethod] + public string file { set; } + [NoAccessorMethod] + public GLib.Icon gicon { owned get; set; } + public bool has_tooltip { get; set; } + [NoAccessorMethod] + public string icon_name { owned get; set; } + [NoAccessorMethod] + public Gtk.Orientation orientation { get; } + [NoAccessorMethod] + public Gdk.Pixbuf pixbuf { owned get; set; } + public Gdk.Screen screen { get; set; } + public int size { get; } + [NoAccessorMethod] + public string stock { owned get; set; } + public Gtk.ImageType storage_type { get; } + public string title { get; set; } + public string tooltip_markup { get; set; } + public string tooltip_text { get; set; } + public bool visible { get; set; } + public virtual signal void activate (); + public virtual signal bool button_press_event (Gdk.EventButton event); + public virtual signal bool button_release_event (Gdk.EventButton event); + public virtual signal void popup_menu (uint button, uint activate_time); + public virtual signal bool query_tooltip (int x, int y, bool keyboard_mode, Gtk.Tooltip tooltip); + public virtual signal bool scroll_event (Gdk.Event event); + public virtual signal bool size_changed (int size); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Statusbar : Gtk.HBox, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + public weak Gtk.Widget frame; + public weak Gdk.Window grip_window; + public weak GLib.SList keys; + public weak Gtk.Widget label; + public weak GLib.SList messages; + public uint seq_context_id; + public uint seq_message_id; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Statusbar (); + public uint get_context_id (string context_description); + public bool get_has_resize_grip (); + public unowned Gtk.Widget get_message_area (); + public void pop (uint context_id); + public uint push (uint context_id, string text); + public void remove (uint context_id, uint message_id); + public void set_has_resize_grip (bool setting); + public bool has_resize_grip { get; set; } + public virtual signal void text_popped (uint context_id, string text); + public virtual signal void text_pushed (uint context_id, string text); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Style : GLib.Object { + public int attach_count; + [CCode (array_length = false)] + public Gdk.Color[] @base; + [CCode (array_length = false)] + public Gdk.GC[] base_gc; + [CCode (array_length = false)] + public Gdk.Color[] bg; + [CCode (array_length = false)] + public Gdk.GC[] bg_gc; + [CCode (array_length = false)] + public Gdk.Pixmap[] bg_pixmap; + public Gdk.Color black; + public weak Gdk.GC black_gc; + public weak Gdk.Colormap colormap; + [CCode (array_length = false)] + public Gdk.Color[] dark; + [CCode (array_length = false)] + public Gdk.GC[] dark_gc; + public int depth; + [CCode (array_length = false)] + public Gdk.Color[] fg; + [CCode (array_length = false)] + public Gdk.GC[] fg_gc; + public weak Pango.FontDescription font_desc; + public weak GLib.SList icon_factories; + [CCode (array_length = false)] + public Gdk.Color[] light; + [CCode (array_length = false)] + public Gdk.GC[] light_gc; + [CCode (array_length = false)] + public Gdk.Color[] mid; + [CCode (array_length = false)] + public Gdk.GC[] mid_gc; + public weak GLib.Array property_cache; + public weak Gtk.RcStyle rc_style; + public weak GLib.SList styles; + [CCode (array_length = false)] + public Gdk.Color[] text; + [CCode (array_length = false)] + public Gdk.Color[] text_aa; + [CCode (array_length = false)] + public Gdk.GC[] text_aa_gc; + [CCode (array_length = false)] + public Gdk.GC[] text_gc; + public Gdk.Color white; + public weak Gdk.GC white_gc; + public int xthickness; + public int ythickness; + [CCode (has_construct_function = false)] + public Style (); + public void apply_default_background (Gdk.Window window, bool set_bg, Gtk.StateType state_type, Gdk.Rectangle area, int x, int y, int width, int height); + public unowned Gtk.Style attach (Gdk.Window window); + [NoWrapper] + public virtual unowned Gtk.Style clone (); + public virtual Gtk.Style copy (); + public void detach (); + [NoWrapper] + public virtual void draw_arrow (Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, Gtk.ArrowType arrow_type, bool fill, int x, int y, int width, int height); + [NoWrapper] + public virtual void draw_box (Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, int width, int height); + [NoWrapper] + public virtual void draw_box_gap (Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, int width, int height, Gtk.PositionType gap_side, int gap_x, int gap_width); + [NoWrapper] + public virtual void draw_check (Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, int width, int height); + [NoWrapper] + public virtual void draw_diamond (Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, int width, int height); + [NoWrapper] + public virtual void draw_expander (Gdk.Window window, Gtk.StateType state_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, Gtk.ExpanderStyle expander_style); + [NoWrapper] + public virtual void draw_extension (Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, int width, int height, Gtk.PositionType gap_side); + [NoWrapper] + public virtual void draw_flat_box (Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, int width, int height); + [NoWrapper] + public virtual void draw_focus (Gdk.Window window, Gtk.StateType state_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, int width, int height); + [NoWrapper] + public virtual void draw_handle (Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, int width, int height, Gtk.Orientation orientation); + [NoWrapper] + public virtual void draw_hline (Gdk.Window window, Gtk.StateType state_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x1, int x2, int y); + [NoWrapper] + public virtual void draw_layout (Gdk.Window window, Gtk.StateType state_type, bool use_text, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, Pango.Layout layout); + [NoWrapper] + public virtual void draw_option (Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, int width, int height); + [NoWrapper] + public virtual void draw_polygon (Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, Gdk.Point point, int npoints, bool fill); + [NoWrapper] + public virtual void draw_resize_grip (Gdk.Window window, Gtk.StateType state_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, Gdk.WindowEdge edge, int x, int y, int width, int height); + [NoWrapper] + public virtual void draw_shadow (Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, int width, int height); + [NoWrapper] + public virtual void draw_shadow_gap (Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, int width, int height, Gtk.PositionType gap_side, int gap_x, int gap_width); + [NoWrapper] + public virtual void draw_slider (Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, int width, int height, Gtk.Orientation orientation); + [NoWrapper] + public virtual void draw_spinner (Gdk.Window window, Gtk.StateType state_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, uint step, int x, int y, int width, int height); + [NoWrapper] + public virtual void draw_string (Gdk.Window window, Gtk.StateType state_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, string str); + [NoWrapper] + public virtual void draw_tab (Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, int width, int height); + [NoWrapper] + public virtual void draw_vline (Gdk.Window window, Gtk.StateType state_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int y1_, int y2_, int x); + public void @get (GLib.Type widget_type, ...); + public void get_style_property (GLib.Type widget_type, string property_name, out GLib.Value value); + public void get_valist (GLib.Type widget_type, string first_property_name, void* var_args); + [NoWrapper] + public virtual void init_from_rc (Gtk.RcStyle rc_style); + public bool lookup_color (string color_name, out Gdk.Color color); + public unowned Gtk.IconSet lookup_icon_set (string stock_id); + public virtual unowned Gdk.Pixbuf render_icon (Gtk.IconSource source, Gtk.TextDirection direction, Gtk.StateType state, Gtk.IconSize size, Gtk.Widget widget, string detail); + public virtual void set_background (Gdk.Window window, Gtk.StateType state_type); + public virtual signal void realize (); + public virtual signal void unrealize (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Table : Gtk.Container, Atk.Implementor, Gtk.Buildable { + public weak GLib.List children; + public weak Gtk.TableRowCol cols; + public uint16 ncols; + public uint16 nrows; + public weak Gtk.TableRowCol rows; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Table (uint rows, uint columns, bool homogeneous); + public void attach (Gtk.Widget child, uint left_attach, uint right_attach, uint top_attach, uint bottom_attach, Gtk.AttachOptions xoptions, Gtk.AttachOptions yoptions, uint xpadding, uint ypadding); + public void attach_defaults (Gtk.Widget widget, uint left_attach, uint right_attach, uint top_attach, uint bottom_attach); + public uint get_col_spacing (uint column); + public uint get_default_col_spacing (); + public uint get_default_row_spacing (); + public bool get_homogeneous (); + public uint get_row_spacing (uint row); + public void resize (uint rows, uint columns); + public void set_col_spacing (uint column, uint spacing); + public void set_col_spacings (uint spacing); + public void set_homogeneous (bool homogeneous); + public void set_row_spacing (uint row, uint spacing); + public void set_row_spacings (uint spacing); + [NoAccessorMethod] + public uint column_spacing { get; set; } + public bool homogeneous { get; set; } + [NoAccessorMethod] + public uint n_columns { get; set; } + [NoAccessorMethod] + public uint n_rows { get; set; } + [NoAccessorMethod] + public uint row_spacing { get; set; } + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class TableChild { + public uint16 bottom_attach; + public uint16 left_attach; + public uint16 right_attach; + public uint16 top_attach; + public weak Gtk.Widget widget; + public uint xexpand; + public uint xfill; + public uint16 xpadding; + public uint xshrink; + public uint yexpand; + public uint yfill; + public uint16 ypadding; + public uint yshrink; + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class TableRowCol { + public uint16 allocation; + public uint empty; + public uint expand; + public uint need_expand; + public uint need_shrink; + public uint16 requisition; + public uint shrink; + public uint16 spacing; + } + [Compact] + [CCode (ref_function = "gtk_target_list_ref", unref_function = "gtk_target_list_unref", type_id = "GTK_TYPE_TARGET_LIST", cheader_filename = "gtk/gtk.h")] + public class TargetList { + public weak GLib.List list; + public uint ref_count; + [CCode (has_construct_function = false)] + public TargetList (Gtk.TargetEntry[] targets); + public void add (Gdk.Atom target, uint flags, uint info); + public void add_image_targets (uint info, bool writable); + public void add_rich_text_targets (uint info, bool deserializable, Gtk.TextBuffer buffer); + public void add_table (Gtk.TargetEntry[] targets, uint ntargets); + public void add_text_targets (uint info); + public void add_uri_targets (uint info); + public bool find (Gdk.Atom target, uint info); + public void remove (Gdk.Atom target); + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class TargetPair { + public uint flags; + public uint info; + public Gdk.Atom target; + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class TearoffMenuItem : Gtk.MenuItem, Atk.Implementor, Gtk.Buildable, Gtk.Activatable { + public uint torn_off; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public TearoffMenuItem (); + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class TextAppearance { + public Gdk.Color bg_color; + public weak Gdk.Bitmap bg_stipple; + public uint draw_bg; + public Gdk.Color fg_color; + public weak Gdk.Bitmap fg_stipple; + public uint inside_selection; + public uint is_text; + public uint pad1; + public uint pad2; + public uint pad3; + public uint pad4; + public void* padding1; + public int rise; + public uint strikethrough; + public uint underline; + } + [Compact] + [CCode (ref_function = "gtk_text_attributes_ref", unref_function = "gtk_text_attributes_unref", type_id = "GTK_TYPE_TEXT_ATTRIBUTES", cheader_filename = "gtk/gtk.h")] + public class TextAttributes { + public weak Gtk.TextAppearance appearance; + public uint bg_full_height; + public Gtk.TextDirection direction; + public uint editable; + public weak Pango.FontDescription font; + public double font_scale; + public int indent; + public uint invisible; + public Gtk.Justification justification; + public weak Pango.Language language; + public int left_margin; + public uint pad1; + public uint pad2; + public uint pad3; + public uint pad4; + public Gdk.Color pg_bg_color; + public int pixels_above_lines; + public int pixels_below_lines; + public int pixels_inside_wrap; + public uint realized; + public uint refcount; + public int right_margin; + public weak Pango.TabArray tabs; + public Gtk.WrapMode wrap_mode; + [CCode (has_construct_function = false)] + public TextAttributes (); + public Gtk.TextAttributes copy (); + public void copy_values (Gtk.TextAttributes dest); + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class TextBTree { + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class TextBuffer : GLib.Object { + public weak Gtk.TextBTree btree; + public weak GLib.SList clipboard_contents_buffers; + public weak Gtk.TextLogAttrCache log_attr_cache; + public uint modified; + public weak GLib.SList selection_clipboards; + public uint user_action_count; + [CCode (has_construct_function = false)] + public TextBuffer (Gtk.TextTagTable? table); + public void add_mark (Gtk.TextMark mark, Gtk.TextIter where); + public void add_selection_clipboard (Gtk.Clipboard clipboard); + public void apply_tag_by_name (string name, Gtk.TextIter start, Gtk.TextIter end); + public bool backspace (Gtk.TextIter iter, bool interactive, bool default_editable); + public void copy_clipboard (Gtk.Clipboard clipboard); + public unowned Gtk.TextChildAnchor create_child_anchor (Gtk.TextIter iter); + public unowned Gtk.TextMark create_mark (string? mark_name, Gtk.TextIter where, bool left_gravity); + public unowned Gtk.TextTag create_tag (string tag_name, ...); + public void cut_clipboard (Gtk.Clipboard clipboard, bool default_editable); + public void @delete (Gtk.TextIter start, Gtk.TextIter end); + public bool delete_interactive (Gtk.TextIter start_iter, Gtk.TextIter end_iter, bool default_editable); + public void delete_mark (Gtk.TextMark mark); + public void delete_mark_by_name (string name); + public bool delete_selection (bool interactive, bool default_editable); + public bool deserialize (Gtk.TextBuffer content_buffer, Gdk.Atom format, Gtk.TextIter iter, [CCode (array_length_type = "gsize")] uint8[] data) throws GLib.Error; + public bool deserialize_get_can_create_tags (Gdk.Atom format); + public void deserialize_set_can_create_tags (Gdk.Atom format, bool can_create_tags); + public void get_bounds (out Gtk.TextIter start, out Gtk.TextIter end); + public int get_char_count (); + public unowned Gtk.TargetList get_copy_target_list (); + public Gdk.Atom[] get_deserialize_formats (); + public void get_end_iter (out Gtk.TextIter iter); + public bool get_has_selection (); + public unowned Gtk.TextMark get_insert (); + public void get_iter_at_child_anchor (out Gtk.TextIter iter, Gtk.TextChildAnchor anchor); + public void get_iter_at_line (out Gtk.TextIter iter, int line_number); + public void get_iter_at_line_index (out Gtk.TextIter iter, int line_number, int byte_index); + public void get_iter_at_line_offset (out Gtk.TextIter iter, int line_number, int char_offset); + public void get_iter_at_mark (out Gtk.TextIter iter, Gtk.TextMark mark); + public void get_iter_at_offset (out Gtk.TextIter iter, int char_offset); + public int get_line_count (); + public unowned Gtk.TextMark get_mark (string name); + public bool get_modified (); + public unowned Gtk.TargetList get_paste_target_list (); + public unowned Gtk.TextMark get_selection_bound (); + public bool get_selection_bounds (out Gtk.TextIter start, out Gtk.TextIter end); + public Gdk.Atom[] get_serialize_formats (); + public unowned string get_slice (Gtk.TextIter start, Gtk.TextIter end, bool include_hidden_chars); + public void get_start_iter (out Gtk.TextIter iter); + public unowned Gtk.TextTagTable get_tag_table (); + public string get_text (Gtk.TextIter start, Gtk.TextIter end, bool include_hidden_chars); + public void insert (Gtk.TextIter iter, string text, int len); + public void insert_at_cursor (string text, int len); + public bool insert_interactive (Gtk.TextIter iter, string text, int len, bool default_editable); + public bool insert_interactive_at_cursor (string text, int len, bool default_editable); + public void insert_range (Gtk.TextIter iter, Gtk.TextIter start, Gtk.TextIter end); + public bool insert_range_interactive (Gtk.TextIter iter, Gtk.TextIter start, Gtk.TextIter end, bool default_editable); + public void insert_with_tags (Gtk.TextIter iter, string text, int len, ...); + public void insert_with_tags_by_name (Gtk.TextIter iter, string text, int len, ...); + public void move_mark (Gtk.TextMark mark, Gtk.TextIter where); + public void move_mark_by_name (string name, Gtk.TextIter where); + public void paste_clipboard (Gtk.Clipboard clipboard, Gtk.TextIter? override_location, bool default_editable); + public void place_cursor (Gtk.TextIter where); + public Gdk.Atom register_deserialize_format (string mime_type, owned Gtk.TextBufferDeserializeFunc function); + public Gdk.Atom register_deserialize_tagset (string tagset_name); + public Gdk.Atom register_serialize_format (string mime_type, owned Gtk.TextBufferSerializeFunc function); + public Gdk.Atom register_serialize_tagset (string tagset_name); + public void remove_all_tags (Gtk.TextIter start, Gtk.TextIter end); + public void remove_selection_clipboard (Gtk.Clipboard clipboard); + public void remove_tag_by_name (string name, Gtk.TextIter start, Gtk.TextIter end); + public void select_range (Gtk.TextIter ins, Gtk.TextIter bound); + [CCode (array_length_type = "gsize")] + public uint8[] serialize (Gtk.TextBuffer content_buffer, Gdk.Atom format, Gtk.TextIter start, Gtk.TextIter end); + public void set_modified (bool setting); + public void set_text (string text, int len = -1); + public void unregister_deserialize_format (Gdk.Atom format); + public void unregister_serialize_format (Gdk.Atom format); + public Gtk.TargetList copy_target_list { get; } + [NoAccessorMethod] + public int cursor_position { get; } + public bool has_selection { get; } + public Gtk.TargetList paste_target_list { get; } + public Gtk.TextTagTable tag_table { get; construct; } + [NoAccessorMethod] + public string text { owned get; set; } + [HasEmitter] + public virtual signal void apply_tag (Gtk.TextTag tag, Gtk.TextIter start_char, Gtk.TextIter end_char); + [HasEmitter] + public virtual signal void begin_user_action (); + public virtual signal void changed (); + public virtual signal void delete_range (Gtk.TextIter start, Gtk.TextIter end); + [HasEmitter] + public virtual signal void end_user_action (); + [HasEmitter] + public virtual signal void insert_child_anchor (Gtk.TextIter pos, Gtk.TextChildAnchor anchor); + [HasEmitter] + public virtual signal void insert_pixbuf (Gtk.TextIter pos, Gdk.Pixbuf pixbuf); + public virtual signal void insert_text (Gtk.TextIter pos, string text, int length); + public virtual signal void mark_deleted (Gtk.TextMark mark); + public virtual signal void mark_set (Gtk.TextIter location, Gtk.TextMark mark); + public virtual signal void modified_changed (); + public virtual signal void paste_done (Gtk.Clipboard clipboard); + [HasEmitter] + public virtual signal void remove_tag (Gtk.TextTag tag, Gtk.TextIter start_char, Gtk.TextIter end_char); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class TextChildAnchor : GLib.Object { + public void* segment; + [CCode (has_construct_function = false)] + public TextChildAnchor (); + public bool get_deleted (); + public GLib.List get_widgets (); + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class TextLogAttrCache { + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class TextMark : GLib.Object { + public void* segment; + [CCode (has_construct_function = false)] + public TextMark (string name, bool left_gravity); + public unowned Gtk.TextBuffer get_buffer (); + public bool get_deleted (); + public bool get_left_gravity (); + public unowned string get_name (); + public bool get_visible (); + public void set_visible (bool setting); + public bool left_gravity { get; construct; } + public string name { get; construct; } + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class TextPendingScroll { + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class TextTag : GLib.Object { + public uint bg_color_set; + public uint bg_full_height_set; + public uint bg_stipple_set; + public uint fg_color_set; + public uint fg_stipple_set; + public uint pad1; + public uint pg_bg_color_set; + public int priority; + public weak Gtk.TextTagTable table; + public weak Gtk.TextAttributes values; + [CCode (has_construct_function = false)] + public TextTag (string name); + public int get_priority (); + public void set_priority (int priority); + [NoAccessorMethod] + public bool accumulative_margin { get; set; } + [NoAccessorMethod] + public string background { set; } + [NoAccessorMethod] + public bool background_full_height { get; set; } + [NoAccessorMethod] + public bool background_full_height_set { get; set; } + [NoAccessorMethod] + public Gdk.Color background_gdk { get; set; } + [NoAccessorMethod] + public bool background_set { get; set; } + [NoAccessorMethod] + public Gdk.Pixmap background_stipple { owned get; set; } + [NoAccessorMethod] + public bool background_stipple_set { get; set; } + [NoAccessorMethod] + public Gtk.TextDirection direction { get; set; } + [NoAccessorMethod] + public bool editable { get; set; } + [NoAccessorMethod] + public bool editable_set { get; set; } + [NoAccessorMethod] + public string family { owned get; set; } + [NoAccessorMethod] + public bool family_set { get; set; } + [NoAccessorMethod] + public string font { owned get; set; } + [NoAccessorMethod] + public Pango.FontDescription font_desc { owned get; set; } + [NoAccessorMethod] + public string foreground { set; } + [NoAccessorMethod] + public Gdk.Color foreground_gdk { get; set; } + [NoAccessorMethod] + public bool foreground_set { get; set; } + [NoAccessorMethod] + public Gdk.Pixmap foreground_stipple { owned get; set; } + [NoAccessorMethod] + public bool foreground_stipple_set { get; set; } + [NoAccessorMethod] + public int indent { get; set; } + [NoAccessorMethod] + public bool indent_set { get; set; } + [NoAccessorMethod] + public bool invisible { get; set; } + [NoAccessorMethod] + public bool invisible_set { get; set; } + [NoAccessorMethod] + public Gtk.Justification justification { get; set; } + [NoAccessorMethod] + public bool justification_set { get; set; } + [NoAccessorMethod] + public string language { owned get; set; } + [NoAccessorMethod] + public bool language_set { get; set; } + [NoAccessorMethod] + public int left_margin { get; set; } + [NoAccessorMethod] + public bool left_margin_set { get; set; } + [NoAccessorMethod] + public string name { owned get; construct; } + [NoAccessorMethod] + public string paragraph_background { set; } + [NoAccessorMethod] + public Gdk.Color paragraph_background_gdk { get; set; } + [NoAccessorMethod] + public bool paragraph_background_set { get; set; } + [NoAccessorMethod] + public int pixels_above_lines { get; set; } + [NoAccessorMethod] + public bool pixels_above_lines_set { get; set; } + [NoAccessorMethod] + public int pixels_below_lines { get; set; } + [NoAccessorMethod] + public bool pixels_below_lines_set { get; set; } + [NoAccessorMethod] + public int pixels_inside_wrap { get; set; } + [NoAccessorMethod] + public bool pixels_inside_wrap_set { get; set; } + [NoAccessorMethod] + public int right_margin { get; set; } + [NoAccessorMethod] + public bool right_margin_set { get; set; } + [NoAccessorMethod] + public int rise { get; set; } + [NoAccessorMethod] + public bool rise_set { get; set; } + [NoAccessorMethod] + public double scale { get; set; } + [NoAccessorMethod] + public bool scale_set { get; set; } + [NoAccessorMethod] + public int size { get; set; } + [NoAccessorMethod] + public double size_points { get; set; } + [NoAccessorMethod] + public bool size_set { get; set; } + [NoAccessorMethod] + public Pango.Stretch stretch { get; set; } + [NoAccessorMethod] + public bool stretch_set { get; set; } + [NoAccessorMethod] + public bool strikethrough { get; set; } + [NoAccessorMethod] + public bool strikethrough_set { get; set; } + [NoAccessorMethod] + public Pango.Style style { get; set; } + [NoAccessorMethod] + public bool style_set { get; set; } + [NoAccessorMethod] + public Pango.TabArray tabs { owned get; set; } + [NoAccessorMethod] + public bool tabs_set { get; set; } + [NoAccessorMethod] + public Pango.Underline underline { get; set; } + [NoAccessorMethod] + public bool underline_set { get; set; } + [NoAccessorMethod] + public Pango.Variant variant { get; set; } + [NoAccessorMethod] + public bool variant_set { get; set; } + [NoAccessorMethod] + public int weight { get; set; } + [NoAccessorMethod] + public bool weight_set { get; set; } + [NoAccessorMethod] + public Gtk.WrapMode wrap_mode { get; set; } + [NoAccessorMethod] + public bool wrap_mode_set { get; set; } + [HasEmitter] + public virtual signal bool event (GLib.Object event_object, Gdk.Event event, Gtk.TextIter iter); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class TextTagTable : GLib.Object { + public int anon_count; + public weak GLib.SList anonymous; + public weak GLib.SList buffers; + public weak GLib.HashTable hash; + [CCode (has_construct_function = false)] + public TextTagTable (); + public void add (Gtk.TextTag tag); + public void @foreach (Gtk.TextTagTableForeach func); + public int get_size (); + public unowned Gtk.TextTag lookup (string name); + public void remove (Gtk.TextTag tag); + public virtual signal void tag_added (Gtk.TextTag tag); + public virtual signal void tag_changed (Gtk.TextTag tag, bool size_changed); + public virtual signal void tag_removed (Gtk.TextTag tag); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class TextView : Gtk.Container, Atk.Implementor, Gtk.Buildable { + public uint blink_timeout; + public weak Gtk.TextWindow bottom_window; + public weak GLib.SList children; + public weak Gtk.TextMark dnd_mark; + public int drag_start_x; + public int drag_start_y; + public weak Gtk.TextMark first_para_mark; + public int first_para_pixels; + public uint first_validate_idle; + public weak Gtk.Adjustment hadjustment; + public int height; + public weak Gtk.IMContext im_context; + public uint incremental_validate_idle; + public Gtk.Justification justify; + public weak Gtk.TextWindow left_window; + public uint mouse_cursor_obscured; + public uint need_im_reset; + public uint onscreen_validated; + public uint overwrite_mode; + public int pending_place_cursor_button; + public weak Gtk.TextPendingScroll pending_scroll; + public weak Gtk.Widget popup_menu; + public weak Gtk.TextWindow right_window; + public uint scroll_timeout; + public uint selection_drag_handler; + public weak Gtk.TextWindow text_window; + public weak Gtk.TextWindow top_window; + public weak Gtk.Adjustment vadjustment; + public int virtual_cursor_x; + public int virtual_cursor_y; + public int width; + public uint width_changed; + public int xoffset; + public int yoffset; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public TextView (); + public void add_child_at_anchor (Gtk.Widget child, Gtk.TextChildAnchor anchor); + public void add_child_in_window (Gtk.Widget child, Gtk.TextWindowType which_window, int xpos, int ypos); + public bool backward_display_line (Gtk.TextIter iter); + public bool backward_display_line_start (Gtk.TextIter iter); + public void buffer_to_window_coords (Gtk.TextWindowType win, int buffer_x, int buffer_y, out int window_x, out int window_y); + public bool forward_display_line (Gtk.TextIter iter); + public bool forward_display_line_end (Gtk.TextIter iter); + public bool get_accepts_tab (); + public int get_border_window_size (Gtk.TextWindowType type); + public unowned Gtk.TextBuffer get_buffer (); + public bool get_cursor_visible (); + public unowned Gtk.TextAttributes get_default_attributes (); + public bool get_editable (); + public int get_indent (); + public void get_iter_at_location (out Gtk.TextIter iter, int x, int y); + public void get_iter_at_position (out Gtk.TextIter iter, out int trailing, int x, int y); + public void get_iter_location (Gtk.TextIter iter, out Gdk.Rectangle location); + public Gtk.Justification get_justification (); + public int get_left_margin (); + public void get_line_at_y (out Gtk.TextIter target_iter, int y, out int line_top); + public void get_line_yrange (Gtk.TextIter iter, out int y, out int height); + public bool get_overwrite (); + public int get_pixels_above_lines (); + public int get_pixels_below_lines (); + public int get_pixels_inside_wrap (); + public int get_right_margin (); + public unowned Pango.TabArray get_tabs (); + public void get_visible_rect (out Gdk.Rectangle visible_rect); + public unowned Gdk.Window get_window (Gtk.TextWindowType win); + public Gtk.TextWindowType get_window_type (Gdk.Window window); + public Gtk.WrapMode get_wrap_mode (); + public void move_child (Gtk.Widget child, int xpos, int ypos); + [NoWrapper] + public virtual void move_focus (Gtk.DirectionType direction); + public bool move_mark_onscreen (Gtk.TextMark mark); + public bool move_visually (Gtk.TextIter iter, int count); + public bool place_cursor_onscreen (); + public void scroll_mark_onscreen (Gtk.TextMark mark); + public bool scroll_to_iter (Gtk.TextIter iter, double within_margin, bool use_align, double xalign, double yalign); + public void scroll_to_mark (Gtk.TextMark mark, double within_margin, bool use_align, double xalign, double yalign); + public void set_accepts_tab (bool accepts_tab); + public void set_border_window_size (Gtk.TextWindowType type, int size); + public void set_buffer (Gtk.TextBuffer buffer); + public void set_cursor_visible (bool setting); + public void set_editable (bool setting); + public void set_indent (int indent); + public void set_justification (Gtk.Justification justification); + public void set_left_margin (int left_margin); + public void set_overwrite (bool overwrite); + public void set_pixels_above_lines (int pixels_above_lines); + public void set_pixels_below_lines (int pixels_below_lines); + public void set_pixels_inside_wrap (int pixels_inside_wrap); + public void set_right_margin (int right_margin); + public void set_tabs (Pango.TabArray tabs); + public void set_wrap_mode (Gtk.WrapMode wrap_mode); + public bool starts_display_line (Gtk.TextIter iter); + public void window_to_buffer_coords (Gtk.TextWindowType win, int window_x, int window_y, out int buffer_x, out int buffer_y); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public TextView.with_buffer (Gtk.TextBuffer buffer); + public bool accepts_tab { get; set; } + public Gtk.TextBuffer buffer { get; set; } + public bool cursor_visible { get; set; } + public bool editable { get; set; } + [NoAccessorMethod] + public string im_module { owned get; set; } + public int indent { get; set; } + public Gtk.Justification justification { get; set; } + public int left_margin { get; set; } + public bool overwrite { get; set; } + public int pixels_above_lines { get; set; } + public int pixels_below_lines { get; set; } + public int pixels_inside_wrap { get; set; } + public int right_margin { get; set; } + public Pango.TabArray tabs { get; set; } + public Gtk.WrapMode wrap_mode { get; set; } + public virtual signal void backspace (); + public virtual signal void copy_clipboard (); + public virtual signal void cut_clipboard (); + public virtual signal void delete_from_cursor (Gtk.DeleteType type, int count); + public virtual signal void insert_at_cursor (string str); + public virtual signal void move_cursor (Gtk.MovementStep step, int count, bool extend_selection); + public virtual signal void move_viewport (Gtk.ScrollStep p0, int p1); + public virtual signal void page_horizontally (int count, bool extend_selection); + public virtual signal void paste_clipboard (); + public virtual signal void populate_popup (Gtk.Menu menu); + public virtual signal void preedit_changed (string p0); + public virtual signal void select_all (bool p0); + public virtual signal void set_anchor (); + public virtual signal void set_scroll_adjustments (Gtk.Adjustment hadjustment, Gtk.Adjustment vadjustment); + public virtual signal void toggle_cursor_visible (); + public virtual signal void toggle_overwrite (); + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class TextWindow { + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class ThemeEngine { + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class ToggleAction : Gtk.Action, Gtk.Buildable { + [CCode (has_construct_function = false)] + public ToggleAction (string name, string? label, string? tooltip, string? stock_id); + public bool get_active (); + public bool get_draw_as_radio (); + public void set_active (bool is_active); + public void set_draw_as_radio (bool draw_as_radio); + public bool active { get; set; } + public bool draw_as_radio { get; set; } + [HasEmitter] + public virtual signal void toggled (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class ToggleButton : Gtk.Button, Atk.Implementor, Gtk.Buildable, Gtk.Activatable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public ToggleButton (); + public bool get_active (); + public bool get_inconsistent (); + public bool get_mode (); + public void set_active (bool is_active); + public void set_inconsistent (bool setting); + public void set_mode (bool draw_indicator); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public ToggleButton.with_label (string label); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public ToggleButton.with_mnemonic (string label); + public bool active { get; set; } + [NoAccessorMethod] + public bool draw_indicator { get; set; } + public bool inconsistent { get; set; } + [HasEmitter] + public virtual signal void toggled (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class ToggleToolButton : Gtk.ToolButton, Atk.Implementor, Gtk.Buildable, Gtk.Activatable { + [CCode (type = "GtkToolItem*", has_construct_function = false)] + public ToggleToolButton (); + [CCode (type = "GtkToolItem*", has_construct_function = false)] + public ToggleToolButton.from_stock (string stock_id); + public bool get_active (); + public void set_active (bool is_active); + public bool active { get; set; } + public virtual signal void toggled (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class ToolButton : Gtk.ToolItem, Atk.Implementor, Gtk.Buildable, Gtk.Activatable { + [CCode (type = "GtkToolItem*", has_construct_function = false)] + public ToolButton (Gtk.Widget? icon_widget, string? label); + [CCode (type = "GtkToolItem*", has_construct_function = false)] + public ToolButton.from_stock (string stock_id); + public unowned string get_icon_name (); + public unowned Gtk.Widget get_icon_widget (); + public unowned string get_label (); + public unowned Gtk.Widget get_label_widget (); + public unowned string get_stock_id (); + public bool get_use_underline (); + public void set_icon_name (string icon_name); + public void set_icon_widget (Gtk.Widget icon_widget); + public void set_label (string label); + public void set_label_widget (Gtk.Widget label_widget); + public void set_stock_id (string stock_id); + public void set_use_underline (bool use_underline); + public string icon_name { get; set; } + public Gtk.Widget icon_widget { get; set; } + public string label { get; set; } + public Gtk.Widget label_widget { get; set; } + public string stock_id { get; set; } + public bool use_underline { get; set; } + public virtual signal void clicked (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class ToolItem : Gtk.Bin, Atk.Implementor, Gtk.Buildable, Gtk.Activatable { + [CCode (has_construct_function = false)] + public ToolItem (); + public Pango.EllipsizeMode get_ellipsize_mode (); + public bool get_expand (); + public bool get_homogeneous (); + public Gtk.IconSize get_icon_size (); + public bool get_is_important (); + public Gtk.Orientation get_orientation (); + public unowned Gtk.Widget get_proxy_menu_item (string menu_item_id); + public Gtk.ReliefStyle get_relief_style (); + public float get_text_alignment (); + public Gtk.Orientation get_text_orientation (); + public unowned Gtk.SizeGroup get_text_size_group (); + public Gtk.ToolbarStyle get_toolbar_style (); + public bool get_use_drag_window (); + public bool get_visible_horizontal (); + public bool get_visible_vertical (); + public void rebuild_menu (); + public unowned Gtk.Widget retrieve_proxy_menu_item (); + public void set_expand (bool expand); + public void set_homogeneous (bool homogeneous); + public void set_is_important (bool is_important); + public void set_proxy_menu_item (string menu_item_id, Gtk.Widget menu_item); + public void set_tooltip_markup (string markup); + public void set_tooltip_text (string text); + public void set_use_drag_window (bool use_drag_window); + public void set_visible_horizontal (bool visible_horizontal); + public void set_visible_vertical (bool visible_vertical); + public bool is_important { get; set; } + public bool visible_horizontal { get; set; } + public bool visible_vertical { get; set; } + public virtual signal bool create_menu_proxy (); + public virtual signal void toolbar_reconfigured (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class ToolItemGroup : Gtk.Container, Atk.Implementor, Gtk.Buildable, Gtk.ToolShell { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public ToolItemGroup (string label); + public bool get_collapsed (); + public unowned Gtk.ToolItem get_drop_item (int x, int y); + public Pango.EllipsizeMode get_ellipsize (); + public Gtk.ReliefStyle get_header_relief (); + public int get_item_position (Gtk.ToolItem item); + public unowned string get_label (); + public unowned Gtk.Widget get_label_widget (); + public uint get_n_items (); + public unowned Gtk.ToolItem get_nth_item (uint index); + public void insert (Gtk.ToolItem item, int position); + public void set_collapsed (bool collapsed); + public void set_ellipsize (Pango.EllipsizeMode ellipsize); + public void set_header_relief (Gtk.ReliefStyle style); + public void set_item_position (Gtk.ToolItem item, int position); + public void set_label (string label); + public void set_label_widget (Gtk.Widget label_widget); + public bool collapsed { get; set; } + public Pango.EllipsizeMode ellipsize { get; set; } + public Gtk.ReliefStyle header_relief { get; set; } + public string label { get; set; } + public Gtk.Widget label_widget { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class ToolPalette : Gtk.Container, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public ToolPalette (); + public void add_drag_dest (Gtk.Widget widget, Gtk.DestDefaults flags, Gtk.ToolPaletteDragTargets targets, Gdk.DragAction actions); + public unowned Gtk.Widget get_drag_item (Gtk.SelectionData selection); + public static Gtk.TargetEntry get_drag_target_group (); + public static Gtk.TargetEntry get_drag_target_item (); + public unowned Gtk.ToolItem get_drop_item (int x, int y); + public unowned Gtk.Adjustment get_hadjustment (); + public Gtk.IconSize get_icon_size (); + public Gtk.ToolbarStyle get_style (); + public unowned Gtk.Adjustment get_vadjustment (); + public void set_drag_source (Gtk.ToolPaletteDragTargets targets); + public void set_icon_size (Gtk.IconSize icon_size); + public void set_style (Gtk.ToolbarStyle style); + public void unset_icon_size (); + public void unset_style (); + public Gtk.IconSize icon_size { get; set; } + [NoAccessorMethod] + public bool icon_size_set { get; set; } + [NoAccessorMethod] + public Gtk.ToolbarStyle toolbar_style { get; set; } + public virtual signal void set_scroll_adjustments (Gtk.Adjustment hadjustment, Gtk.Adjustment vadjustment); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Toolbar : Gtk.Container, Atk.Implementor, Gtk.Buildable, Gtk.ToolShell, Gtk.Orientable { + public int button_maxh; + public int button_maxw; + public weak GLib.List children; + public int num_children; + public Gtk.Orientation orientation; + public Gtk.ToolbarStyle style; + public uint style_set; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Toolbar (); + public int get_drop_index (int x, int y); + public int get_item_index (Gtk.ToolItem item); + public int get_n_items (); + public unowned Gtk.ToolItem get_nth_item (int n); + public bool get_show_arrow (); + public void insert (Gtk.ToolItem item, int pos); + public void set_drop_highlight_item (Gtk.ToolItem tool_item, int index_); + public void set_icon_size (Gtk.IconSize icon_size); + public void set_show_arrow (bool show_arrow); + public void set_style (Gtk.ToolbarStyle style); + public void unset_icon_size (); + public void unset_style (); + public int icon_size { get; set; } + [NoAccessorMethod] + public bool icon_size_set { get; set; } + public bool show_arrow { get; set; } + [NoAccessorMethod] + public Gtk.ToolbarStyle toolbar_style { get; set; } + [NoAccessorMethod] + public bool tooltips { get; set; } + public virtual signal bool focus_home_or_end (bool p0); + public virtual signal void orientation_changed (Gtk.Orientation orientation); + public virtual signal bool popup_context_menu (int x, int y, int button_number); + public virtual signal void style_changed (Gtk.ToolbarStyle style); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Tooltip : GLib.Object { + [CCode (has_construct_function = false)] + protected Tooltip (); + public void set_custom (Gtk.Widget custom_widget); + public void set_icon (Gdk.Pixbuf pixbuf); + public void set_icon_from_gicon (GLib.Icon gicon, Gtk.IconSize size); + public void set_icon_from_icon_name (string icon_name, Gtk.IconSize size); + public void set_icon_from_stock (string stock_id, Gtk.IconSize size); + public void set_markup (string markup); + public void set_text (string text); + public void set_tip_area (Gdk.Rectangle rect); + public static void trigger_tooltip_query (Gdk.Display display); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class TreeModelFilter : GLib.Object, Gtk.TreeModel, Gtk.TreeDragSource { + [CCode (type = "GtkTreeModel*", has_construct_function = false)] + public TreeModelFilter (Gtk.TreeModel child_model, Gtk.TreePath? root); + public void clear_cache (); + public bool convert_child_iter_to_iter (out Gtk.TreeIter filter_iter, Gtk.TreeIter child_iter); + public unowned Gtk.TreePath convert_child_path_to_path (Gtk.TreePath child_path); + public void convert_iter_to_child_iter (out Gtk.TreeIter child_iter, Gtk.TreeIter filter_iter); + public unowned Gtk.TreePath convert_path_to_child_path (Gtk.TreePath filter_path); + public unowned Gtk.TreeModel get_model (); + public void refilter (); + public void set_modify_func ([CCode (array_length_pos = 0.9)] GLib.Type[] types, owned Gtk.TreeModelFilterModifyFunc func); + public void set_visible_column (int column); + public void set_visible_func (owned Gtk.TreeModelFilterVisibleFunc func); + [NoAccessorMethod] + public Gtk.TreeModel child_model { owned get; construct; } + [NoAccessorMethod] + public Gtk.TreePath virtual_root { owned get; construct; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class TreeModelSort : GLib.Object, Gtk.TreeModel, Gtk.TreeSortable, Gtk.TreeDragSource { + public uint changed_id; + public uint child_flags; + public weak Gtk.TreeModel child_model; + public void* default_sort_data; + public weak GLib.DestroyNotify default_sort_destroy; + public weak Gtk.TreeIterCompareFunc default_sort_func; + public uint deleted_id; + public uint has_child_toggled_id; + public uint inserted_id; + public Gtk.SortType order; + public uint reordered_id; + public void* root; + public int sort_column_id; + public weak GLib.List sort_list; + public int stamp; + public int zero_ref_count; + [CCode (has_construct_function = false)] + protected TreeModelSort (); + public void clear_cache (); + public bool convert_child_iter_to_iter (out Gtk.TreeIter sort_iter, Gtk.TreeIter child_iter); + public unowned Gtk.TreePath convert_child_path_to_path (Gtk.TreePath child_path); + public void convert_iter_to_child_iter (out Gtk.TreeIter child_iter, Gtk.TreeIter sorted_iter); + public unowned Gtk.TreePath convert_path_to_child_path (Gtk.TreePath sorted_path); + public unowned Gtk.TreeModel get_model (); + public bool iter_is_valid (Gtk.TreeIter iter); + public void reset_default_sort_func (); + [CCode (type = "GtkTreeModel*", has_construct_function = false)] + public TreeModelSort.with_model (Gtk.TreeModel child_model); + public Gtk.TreeModel model { get; construct; } + } + [Compact] + [Immutable] + [CCode (copy_function = "gtk_tree_path_copy", const_cname = "GtkTreePath", type_id = "GTK_TYPE_TREE_PATH", cheader_filename = "gtk/gtk.h")] + public class TreePath { + [CCode (has_construct_function = false)] + public TreePath (); + public void append_index (int index_); + public int compare (Gtk.TreePath b); + public Gtk.TreePath copy (); + public void down (); + [CCode (has_construct_function = false)] + public TreePath.first (); + [CCode (sentinel = "-1", has_construct_function = false)] + public TreePath.from_indices (...); + [CCode (has_construct_function = false)] + public TreePath.from_string (string path); + public int get_depth (); + [CCode (array_length = false)] + public unowned int[] get_indices (); + public bool is_ancestor (Gtk.TreePath descendant); + public bool is_descendant (Gtk.TreePath ancestor); + public void next (); + public void prepend_index (int index_); + public bool prev (); + public unowned string to_string (); + public bool up (); + } + [Compact] + [Immutable] + [CCode (copy_function = "gtk_tree_row_reference_copy", type_id = "GTK_TYPE_TREE_ROW_REFERENCE", cheader_filename = "gtk/gtk.h")] + public class TreeRowReference { + [CCode (has_construct_function = false)] + public TreeRowReference (Gtk.TreeModel model, Gtk.TreePath path); + public Gtk.TreeRowReference copy (); + public static void deleted (GLib.Object proxy, Gtk.TreePath path); + public unowned Gtk.TreeModel get_model (); + public Gtk.TreePath get_path (); + public static void inserted (GLib.Object proxy, Gtk.TreePath path); + [CCode (has_construct_function = false)] + public TreeRowReference.proxy (GLib.Object proxy, Gtk.TreeModel model, Gtk.TreePath path); + public static void reordered (GLib.Object proxy, Gtk.TreePath path, Gtk.TreeIter iter, int[] new_order); + public bool valid (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class TreeSelection : GLib.Object { + public weak GLib.DestroyNotify destroy; + public weak Gtk.TreeView tree_view; + public Gtk.SelectionMode type; + public void* user_data; + public weak Gtk.TreeSelectionFunc user_func; + [CCode (has_construct_function = false)] + protected TreeSelection (); + public int count_selected_rows (); + public Gtk.SelectionMode get_mode (); + public unowned Gtk.TreeSelectionFunc get_select_function (); + public bool get_selected (out unowned Gtk.TreeModel model, out Gtk.TreeIter iter); + public GLib.List get_selected_rows (out unowned Gtk.TreeModel model); + public unowned Gtk.TreeView get_tree_view (); + public void* get_user_data (); + public bool iter_is_selected (Gtk.TreeIter iter); + public bool path_is_selected (Gtk.TreePath path); + public void select_all (); + public void select_iter (Gtk.TreeIter iter); + public void select_path (Gtk.TreePath path); + public void select_range (Gtk.TreePath start_path, Gtk.TreePath end_path); + public void selected_foreach (Gtk.TreeSelectionForeachFunc func); + public void set_mode (Gtk.SelectionMode type); + public void set_select_function (owned Gtk.TreeSelectionFunc func); + public void unselect_all (); + public void unselect_iter (Gtk.TreeIter iter); + public void unselect_path (Gtk.TreePath path); + public void unselect_range (Gtk.TreePath start_path, Gtk.TreePath end_path); + public virtual signal void changed (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class TreeStore : GLib.Object, Gtk.Buildable, Gtk.TreeModel, Gtk.TreeSortable, Gtk.TreeDragSource, Gtk.TreeDragDest { + [CCode (array_length = false)] + public weak GLib.Type[] column_headers; + public uint columns_dirty; + public void* default_sort_data; + public weak GLib.DestroyNotify default_sort_destroy; + public weak Gtk.TreeIterCompareFunc default_sort_func; + public void* last; + public int n_columns; + public Gtk.SortType order; + public void* root; + public int sort_column_id; + public weak GLib.List sort_list; + public int stamp; + [CCode (sentinel = "", has_construct_function = false)] + public TreeStore (int n_columns, ...); + public void append (out Gtk.TreeIter iter, Gtk.TreeIter? parent); + public void clear (); + public void insert (out Gtk.TreeIter iter, Gtk.TreeIter? parent, int position); + public void insert_after (out Gtk.TreeIter iter, Gtk.TreeIter? parent, Gtk.TreeIter? sibling); + public void insert_before (out Gtk.TreeIter iter, Gtk.TreeIter? parent, Gtk.TreeIter? sibling); + [CCode (sentinel = "-1")] + public void insert_with_values (out Gtk.TreeIter iter, Gtk.TreeIter? parent, int position, ...); + public void insert_with_valuesv (out Gtk.TreeIter iter, Gtk.TreeIter? parent, int position, int columns, GLib.Value[] values); + public bool is_ancestor (Gtk.TreeIter iter, Gtk.TreeIter descendant); + public int iter_depth (Gtk.TreeIter iter); + public bool iter_is_valid (Gtk.TreeIter iter); + public void move_after (ref Gtk.TreeIter iter, Gtk.TreeIter? position); + public void move_before (ref Gtk.TreeIter iter, Gtk.TreeIter? position); + [CCode (cname = "gtk_tree_store_newv", has_construct_function = false)] + public TreeStore.newv ([CCode (array_length_pos = 0.9)] GLib.Type[] types); + public void prepend (out Gtk.TreeIter iter, Gtk.TreeIter? parent); + public bool remove (Gtk.TreeIter iter); + public void reorder (Gtk.TreeIter? parent, int new_order); + [CCode (sentinel = "-1")] + public void @set (Gtk.TreeIter iter, ...); + public void set_column_types ([CCode (array_length_pos = 0.9)] GLib.Type[] types); + public void set_valist (Gtk.TreeIter iter, void* var_args); + public void set_value (Gtk.TreeIter iter, int column, GLib.Value value); + public void set_valuesv (Gtk.TreeIter iter, int columns, GLib.Value[] values); + public void swap (Gtk.TreeIter a, Gtk.TreeIter b); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class TreeView : Gtk.Container, Atk.Implementor, Gtk.Buildable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public TreeView (); + public int append_column (Gtk.TreeViewColumn column); + public void collapse_all (); + public bool collapse_row (Gtk.TreePath path); + public void columns_autosize (); + public void convert_bin_window_to_tree_coords (int bx, int by, out int tx, out int ty); + public void convert_bin_window_to_widget_coords (int bx, int by, out int wx, out int wy); + public void convert_tree_to_bin_window_coords (int tx, int ty, out int bx, out int by); + public void convert_tree_to_widget_coords (int tx, int ty, out int wx, out int wy); + public void convert_widget_to_bin_window_coords (int wx, int wy, out int bx, out int by); + public void convert_widget_to_tree_coords (int wx, int wy, out int tx, out int ty); + public unowned Gdk.Pixmap create_row_drag_icon (Gtk.TreePath path); + public void enable_model_drag_dest (Gtk.TargetEntry[] targets, Gdk.DragAction actions); + public void enable_model_drag_source (Gdk.ModifierType start_button_mask, Gtk.TargetEntry[] targets, Gdk.DragAction actions); + public void expand_all (); + public bool expand_row (Gtk.TreePath path, bool open_all); + public void expand_to_path (Gtk.TreePath path); + public void get_background_area (Gtk.TreePath? path, Gtk.TreeViewColumn? column, out Gdk.Rectangle rect); + public unowned Gdk.Window get_bin_window (); + public void get_cell_area (Gtk.TreePath? path, Gtk.TreeViewColumn? column, out Gdk.Rectangle rect); + public unowned Gtk.TreeViewColumn get_column (int n); + public GLib.List get_columns (); + public void get_cursor (out Gtk.TreePath? path, out unowned Gtk.TreeViewColumn? focus_column); + public bool get_dest_row_at_pos (int drag_x, int drag_y, out Gtk.TreePath? path, out Gtk.TreeViewDropPosition pos); + public void get_drag_dest_row (out Gtk.TreePath? path, out Gtk.TreeViewDropPosition pos); + public bool get_enable_search (); + public bool get_enable_tree_lines (); + public unowned Gtk.TreeViewColumn get_expander_column (); + public bool get_fixed_height_mode (); + public Gtk.TreeViewGridLines get_grid_lines (); + public unowned Gtk.Adjustment get_hadjustment (); + public bool get_headers_clickable (); + public bool get_headers_visible (); + public bool get_hover_expand (); + public bool get_hover_selection (); + public int get_level_indentation (); + public unowned Gtk.TreeModel get_model (); + public bool get_path_at_pos (int x, int y, out Gtk.TreePath? path, out unowned Gtk.TreeViewColumn? column, out int cell_x, out int cell_y); + public bool get_reorderable (); + public unowned Gtk.TreeViewRowSeparatorFunc get_row_separator_func (); + public bool get_rubber_banding (); + public bool get_rules_hint (); + public int get_search_column (); + public unowned Gtk.Entry get_search_entry (); + public unowned Gtk.TreeViewSearchEqualFunc get_search_equal_func (); + public unowned Gtk.TreeViewSearchPositionFunc get_search_position_func (); + public unowned Gtk.TreeSelection get_selection (); + public bool get_show_expanders (); + public int get_tooltip_column (); + public bool get_tooltip_context (out int x, out int y, bool keyboard_tip, out unowned Gtk.TreeModel model, out unowned Gtk.TreePath path, out Gtk.TreeIter iter); + public unowned Gtk.Adjustment get_vadjustment (); + public bool get_visible_range (out unowned Gtk.TreePath start_path, out unowned Gtk.TreePath end_path); + public void get_visible_rect (out Gdk.Rectangle visible_rect); + public int insert_column (Gtk.TreeViewColumn column, int position); + public int insert_column_with_attributes (int position, string? title, Gtk.CellRenderer cell, ...); + public int insert_column_with_data_func (int position, string title, Gtk.CellRenderer cell, owned Gtk.TreeCellDataFunc func); + [CCode (cname = "gtk_tree_view_row_expanded")] + public bool is_row_expanded (Gtk.TreePath path); + public bool is_rubber_banding_active (); + public void map_expanded_rows (Gtk.TreeViewMappingFunc func, void* data); + public void move_column_after (Gtk.TreeViewColumn column, Gtk.TreeViewColumn base_column); + public int remove_column (Gtk.TreeViewColumn column); + public void scroll_to_cell (Gtk.TreePath? path, Gtk.TreeViewColumn? column, bool use_align, float row_align, float col_align); + public void scroll_to_point (int tree_x, int tree_y); + public void set_column_drag_function (owned Gtk.TreeViewColumnDropFunc func); + public void set_cursor (Gtk.TreePath path, Gtk.TreeViewColumn? focus_column, bool start_editing); + public void set_cursor_on_cell (Gtk.TreePath path, Gtk.TreeViewColumn focus_column, Gtk.CellRenderer focus_cell, bool start_editing); + public void set_destroy_count_func (owned Gtk.TreeDestroyCountFunc func); + public void set_drag_dest_row (Gtk.TreePath? path, Gtk.TreeViewDropPosition pos); + public void set_enable_search (bool enable_search); + public void set_enable_tree_lines (bool enabled); + public void set_expander_column (Gtk.TreeViewColumn column); + public void set_fixed_height_mode (bool enable); + public void set_grid_lines (Gtk.TreeViewGridLines grid_lines); + public void set_hadjustment (Gtk.Adjustment adjustment); + public void set_headers_clickable (bool setting); + public void set_headers_visible (bool headers_visible); + public void set_hover_expand (bool expand); + public void set_hover_selection (bool hover); + public void set_level_indentation (int indentation); + public void set_model (Gtk.TreeModel? model); + public void set_reorderable (bool reorderable); + public void set_row_separator_func (owned Gtk.TreeViewRowSeparatorFunc func); + public void set_rubber_banding (bool enable); + public void set_rules_hint (bool setting); + public void set_search_column (int column); + public void set_search_entry (Gtk.Entry entry); + public void set_search_equal_func (owned Gtk.TreeViewSearchEqualFunc search_equal_func); + public void set_search_position_func (owned Gtk.TreeViewSearchPositionFunc func); + public void set_show_expanders (bool enabled); + public void set_tooltip_cell (Gtk.Tooltip tooltip, Gtk.TreePath path, Gtk.TreeViewColumn column, Gtk.CellRenderer cell); + public void set_tooltip_column (int column); + public void set_tooltip_row (Gtk.Tooltip tooltip, Gtk.TreePath path); + public void set_vadjustment (Gtk.Adjustment adjustment); + public void unset_rows_drag_dest (); + public void unset_rows_drag_source (); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public TreeView.with_model (Gtk.TreeModel model); + [NoAccessorMethod] + public Gtk.TreeViewGridLines enable_grid_lines { get; set; } + public bool enable_search { get; set; } + public bool enable_tree_lines { get; set; } + public Gtk.TreeViewColumn expander_column { get; set; } + public bool fixed_height_mode { get; set; } + public Gtk.Adjustment hadjustment { get; set; } + public bool headers_clickable { get; set; } + public bool headers_visible { get; set; } + public bool hover_expand { get; set; } + public bool hover_selection { get; set; } + public int level_indentation { get; set; } + public Gtk.TreeModel model { get; set; } + public bool reorderable { get; set; } + public bool rubber_banding { get; set; } + public bool rules_hint { get; set; } + public int search_column { get; set; } + public bool show_expanders { get; set; } + public int tooltip_column { get; set; } + public Gtk.Adjustment vadjustment { get; set; } + public virtual signal void columns_changed (); + public virtual signal void cursor_changed (); + public virtual signal bool expand_collapse_cursor_row (bool logical, bool expand, bool open_all); + public virtual signal bool move_cursor (Gtk.MovementStep step, int count); + [HasEmitter] + public virtual signal void row_activated (Gtk.TreePath path, Gtk.TreeViewColumn column); + public virtual signal void row_collapsed (Gtk.TreeIter iter, Gtk.TreePath path); + public virtual signal void row_expanded (Gtk.TreeIter iter, Gtk.TreePath path); + public virtual signal bool select_all (); + public virtual signal bool select_cursor_parent (); + public virtual signal bool select_cursor_row (bool start_editing); + public virtual signal void set_scroll_adjustments (Gtk.Adjustment hadjustment, Gtk.Adjustment vadjustment); + public virtual signal bool start_interactive_search (); + public virtual signal bool test_collapse_row (Gtk.TreeIter iter, Gtk.TreePath path); + public virtual signal bool test_expand_row (Gtk.TreeIter iter, Gtk.TreePath path); + public virtual signal bool toggle_cursor_row (); + public virtual signal bool unselect_all (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class TreeViewColumn : Gtk.Object, Gtk.Buildable, Gtk.CellLayout { + public weak Gtk.Widget arrow; + public weak Gtk.Widget button; + public int button_request; + public weak GLib.List cell_list; + public weak Gtk.Widget child; + public Gtk.TreeViewColumnSizing column_type; + public uint dirty; + public int drag_x; + public int drag_y; + public weak Gtk.CellEditable editable_widget; + public uint maybe_reordered; + public uint property_changed_signal; + public int requested_width; + public int resized_width; + public uint show_sort_indicator; + public uint sort_clicked_signal; + public uint sort_column_changed_signal; + public weak Gtk.Widget tree_view; + public uint use_resized_width; + public weak Gdk.Window window; + public float xalign; + [CCode (has_construct_function = false)] + public TreeViewColumn (); + public bool cell_get_position (Gtk.CellRenderer cell_renderer, out int start_pos, out int width); + public void cell_get_size (out Gdk.Rectangle cell_area, out int x_offset, out int y_offset, out int width, out int height); + public bool cell_is_visible (); + public void cell_set_cell_data (Gtk.TreeModel tree_model, Gtk.TreeIter iter, bool is_expander, bool is_expanded); + public void focus_cell (Gtk.CellRenderer cell); + public float get_alignment (); + public bool get_clickable (); + public bool get_expand (); + public int get_fixed_width (); + public int get_max_width (); + public int get_min_width (); + public bool get_reorderable (); + public bool get_resizable (); + public Gtk.TreeViewColumnSizing get_sizing (); + public int get_sort_column_id (); + public bool get_sort_indicator (); + public Gtk.SortType get_sort_order (); + public int get_spacing (); + public unowned string get_title (); + public unowned Gtk.Widget get_tree_view (); + public bool get_visible (); + public unowned Gtk.Widget get_widget (); + public int get_width (); + public void queue_resize (); + public void set_alignment (float xalign); + public void set_attributes (Gtk.CellRenderer cell_renderer, ...); + public void set_clickable (bool clickable); + public void set_expand (bool expand); + public void set_fixed_width (int fixed_width); + public void set_max_width (int max_width); + public void set_min_width (int min_width); + public void set_reorderable (bool reorderable); + public void set_resizable (bool resizable); + public void set_sizing (Gtk.TreeViewColumnSizing type); + public void set_sort_column_id (int sort_column_id); + public void set_sort_indicator (bool setting); + public void set_sort_order (Gtk.SortType order); + public void set_spacing (int spacing); + public void set_title (string title); + public void set_visible (bool visible); + public void set_widget (Gtk.Widget widget); + [CCode (has_construct_function = false)] + public TreeViewColumn.with_attributes (string? title, Gtk.CellRenderer cell, ...); + public float alignment { get; set; } + public bool clickable { get; set; } + public bool expand { get; set; } + public int fixed_width { get; set; } + public int max_width { get; set; } + public int min_width { get; set; } + public bool reorderable { get; set; } + public bool resizable { get; set; } + public Gtk.TreeViewColumnSizing sizing { get; set; } + public int sort_column_id { get; set; } + public bool sort_indicator { get; set; } + public Gtk.SortType sort_order { get; set; } + public int spacing { get; set; } + public string title { get; set; } + public bool visible { get; set; } + public Gtk.Widget widget { get; set; } + public int width { get; } + [HasEmitter] + public virtual signal void clicked (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class UIManager : GLib.Object, Gtk.Buildable { + [CCode (has_construct_function = false)] + public UIManager (); + public void add_ui (uint merge_id, string path, string name, string action, Gtk.UIManagerItemType type, bool top); + public uint add_ui_from_file (string filename) throws GLib.Error; + public uint add_ui_from_string (string buffer, ssize_t length) throws GLib.Error; + public void ensure_update (); + public unowned Gtk.AccelGroup get_accel_group (); + public virtual unowned Gtk.Action get_action (string path); + public unowned GLib.List get_action_groups (); + public bool get_add_tearoffs (); + public GLib.SList get_toplevels (Gtk.UIManagerItemType types); + public unowned string get_ui (); + public virtual unowned Gtk.Widget get_widget (string path); + public void insert_action_group (Gtk.ActionGroup action_group, int pos); + public uint new_merge_id (); + public void remove_action_group (Gtk.ActionGroup action_group); + public void remove_ui (uint merge_id); + public void set_add_tearoffs (bool add_tearoffs); + public bool add_tearoffs { get; set; } + public string ui { get; } + public virtual signal void actions_changed (); + public virtual signal void add_widget (Gtk.Widget widget); + public virtual signal void connect_proxy (Gtk.Action action, Gtk.Widget proxy); + public virtual signal void disconnect_proxy (Gtk.Action action, Gtk.Widget proxy); + public virtual signal void post_activate (Gtk.Action action); + public virtual signal void pre_activate (Gtk.Action action); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class VBox : Gtk.Box, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public VBox (bool homogeneous, int spacing); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class VButtonBox : Gtk.ButtonBox, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public VButtonBox (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class VPaned : Gtk.Paned, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public VPaned (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class VRuler : Gtk.Ruler, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public VRuler (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class VScale : Gtk.Scale, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public VScale (Gtk.Adjustment? adjustment); + [CCode (type = "GtkWidget*", has_construct_function = false)] + public VScale.with_range (double min, double max, double step); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class VScrollbar : Gtk.Scrollbar, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public VScrollbar (Gtk.Adjustment? adjustment); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class VSeparator : Gtk.Separator, Atk.Implementor, Gtk.Buildable, Gtk.Orientable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public VSeparator (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Viewport : Gtk.Bin, Atk.Implementor, Gtk.Buildable { + public weak Gdk.Window bin_window; + public weak Gdk.Window view_window; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Viewport (Gtk.Adjustment? hadjustment, Gtk.Adjustment? vadjustment); + public unowned Gdk.Window get_bin_window (); + public unowned Gtk.Adjustment get_hadjustment (); + public Gtk.ShadowType get_shadow_type (); + public unowned Gtk.Adjustment get_vadjustment (); + public void set_hadjustment (Gtk.Adjustment adjustment); + public void set_shadow_type (Gtk.ShadowType type); + public void set_vadjustment (Gtk.Adjustment adjustment); + public Gtk.Adjustment hadjustment { get; set construct; } + public Gtk.ShadowType shadow_type { get; set; } + public Gtk.Adjustment vadjustment { get; set construct; } + public virtual signal void set_scroll_adjustments (Gtk.Adjustment hadjustment, Gtk.Adjustment vadjustment); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class VolumeButton : Gtk.ScaleButton, Atk.Implementor, Gtk.Buildable, Gtk.Orientable, Gtk.Activatable { + [CCode (type = "GtkWidget*", has_construct_function = false)] + public VolumeButton (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Widget : Gtk.Object, Atk.Implementor, Gtk.Buildable { + public Gtk.Allocation allocation; + public Gtk.Requisition requisition; + public uchar saved_state; + public uchar state; + public Gdk.Window window; + [CCode (has_new_function = false, construct_function = "gtk_widget_new")] + public Widget (...); + public bool activate (); + public void add_accelerator (string accel_signal, Gtk.AccelGroup accel_group, uint accel_key, Gdk.ModifierType accel_mods, Gtk.AccelFlags accel_flags); + public void add_events (int events); + public void add_mnemonic_label (Gtk.Widget label); + public bool child_focus (Gtk.DirectionType direction); + public void class_path (out uint path_length, out unowned string path, out unowned string path_reversed); + public Pango.Context create_pango_context (); + public Pango.Layout create_pango_layout (string? text); + public void destroyed (out unowned Gtk.Widget widget_pointer); + [NoWrapper] + public virtual void dispatch_child_properties_changed (uint n_pspecs, out unowned GLib.ParamSpec pspecs); + public void ensure_style (); + public void error_bell (); + [CCode (cname = "gtk_widget_class_find_style_property")] + public class unowned GLib.ParamSpec find_style_property (string property_name); + public void freeze_child_notify (); + public virtual unowned Atk.Object get_accessible (); + public void get_allocation (out Gtk.Allocation allocation); + public unowned Gtk.Widget get_ancestor (GLib.Type widget_type); + public bool get_app_paintable (); + public bool get_can_default (); + public bool get_can_focus (); + public void get_child_requisition (out Gtk.Requisition requisition); + public bool get_child_visible (); + public unowned Gtk.Clipboard get_clipboard (Gdk.Atom selection); + public unowned Gdk.Colormap get_colormap (); + public unowned string get_composite_name (); + public static unowned Gdk.Colormap get_default_colormap (); + public static Gtk.TextDirection get_default_direction (); + public static unowned Gtk.Style get_default_style (); + public static unowned Gdk.Visual get_default_visual (); + public Gtk.TextDirection get_direction (); + public unowned Gdk.Display get_display (); + public bool get_double_buffered (); + public int get_events (); + public Gdk.ExtensionMode get_extension_events (); + [CCode (cname = "GTK_WIDGET_FLAGS")] + public Gtk.WidgetFlags get_flags (); + public bool get_has_tooltip (); + public bool get_has_window (); + public bool get_mapped (); + public unowned Gtk.RcStyle get_modifier_style (); + public bool get_no_show_all (); + public unowned Pango.Context get_pango_context (); + public unowned Gtk.Widget get_parent (); + public unowned Gdk.Window get_parent_window (); + public void get_pointer (out int x, out int y); + public bool get_realized (); + public bool get_receives_default (); + public void get_requisition (Gtk.Requisition requisition); + public unowned Gdk.Window get_root_window (); + public unowned Gdk.Screen get_screen (); + public bool get_sensitive (); + public unowned Gtk.Settings get_settings (); + public void get_size_request (out int width, out int height); + public unowned Gdk.Pixmap get_snapshot (Gdk.Rectangle clip_rect); + public Gtk.StateType get_state (); + public unowned Gtk.Style get_style (); + public unowned string get_tooltip_markup (); + public unowned string get_tooltip_text (); + public unowned Gtk.Window get_tooltip_window (); + public unowned Gtk.Widget get_toplevel (); + public bool get_visible (); + public unowned Gdk.Visual get_visual (); + public unowned Gdk.Window get_window (); + public void grab_default (); + [CCode (cname = "GTK_WIDGET_HAS_GRAB")] + public bool has_grab (); + public bool has_rc_style (); + public bool has_screen (); + public virtual void hide_all (); + public bool hide_on_delete (); + public void input_shape_combine_mask (Gdk.Bitmap? shape_mask, int offset_x, int offset_y); + [CCode (cname = "gtk_widget_class_install_style_property")] + public class void install_style_property (GLib.ParamSpec pspec); + [CCode (cname = "gtk_widget_class_install_style_property_parser")] + public class void install_style_property_parser (GLib.ParamSpec pspec, Gtk.RcPropertyParser parser); + public bool intersect (Gdk.Rectangle area, Gdk.Rectangle? intersection); + public bool is_ancestor (Gtk.Widget ancestor); + public bool is_composited (); + [CCode (cname = "GTK_WIDGET_DOUBLE_BUFFERED")] + public bool is_double_buffered (); + [CCode (cname = "GTK_WIDGET_DRAWABLE")] + public bool is_drawable (); + [CCode (cname = "GTK_WIDGET_MAPPED")] + public bool is_mapped (); + [CCode (cname = "GTK_WIDGET_NO_WINDOW")] + public bool is_no_window (); + [CCode (cname = "GTK_WIDGET_PARENT_SENSITIVE")] + public bool is_parent_sensitive (); + [CCode (cname = "GTK_WIDGET_RC_STYLE")] + public bool is_rc_style (); + [CCode (cname = "GTK_WIDGET_REALIZED")] + public bool is_realized (); + public bool is_sensitive (); + [CCode (cname = "GTK_WIDGET_TOPLEVEL")] + public bool is_toplevel (); + public GLib.List list_accel_closures (); + public GLib.List list_mnemonic_labels (); + [CCode (cname = "gtk_widget_class_list_style_properties")] + public class unowned GLib.ParamSpec list_style_properties (uint n_properties); + public void modify_base (Gtk.StateType state, Gdk.Color? color); + public void modify_bg (Gtk.StateType state, Gdk.Color? color); + public void modify_cursor (Gdk.Color? primary, Gdk.Color? secondary); + public void modify_fg (Gtk.StateType state, Gdk.Color? color); + public void modify_font (Pango.FontDescription? font_desc); + public void modify_style (Gtk.RcStyle style); + public void modify_text (Gtk.StateType state, Gdk.Color? color); + public void path (out uint path_length, out unowned string path, out unowned string path_reversed); + public static void pop_colormap (); + public static void pop_composite_child (); + public static void push_colormap (Gdk.Colormap cmap); + public static void push_composite_child (); + public void queue_draw (); + public void queue_draw_area (int x, int y, int width, int height); + public void queue_resize (); + public void queue_resize_no_redraw (); + public unowned Gdk.Region region_intersect (Gdk.Region region); + public bool remove_accelerator (Gtk.AccelGroup accel_group, uint accel_key, Gdk.ModifierType accel_mods); + public void remove_mnemonic_label (Gtk.Widget label); + public Gdk.Pixbuf render_icon (string stock_id, Gtk.IconSize size, string? detail); + public void reparent (Gtk.Widget new_parent); + public void reset_rc_styles (); + public void reset_shapes (); + public int send_expose (Gdk.Event event); + public void set_accel_path (string accel_path, Gtk.AccelGroup accel_group); + public void set_allocation (Gtk.Allocation allocation); + public void set_app_paintable (bool app_paintable); + public void set_can_default (bool can_default); + public void set_can_focus (bool can_focus); + public void set_child_visible (bool is_visible); + public void set_colormap (Gdk.Colormap colormap); + public void set_composite_name (string name); + public static void set_default_colormap (Gdk.Colormap colormap); + public static void set_default_direction (Gtk.TextDirection dir); + public void set_direction (Gtk.TextDirection dir); + public void set_double_buffered (bool double_buffered); + public void set_events (int events); + public void set_extension_events (Gdk.ExtensionMode mode); + [CCode (cname = "GTK_WIDGET_SET_FLAGS")] + public void set_flags (Gtk.WidgetFlags flags); + public void set_has_tooltip (bool has_tooltip); + public void set_has_window (bool has_window); + public void set_mapped (bool mapped); + public void set_no_show_all (bool no_show_all); + public void set_parent (Gtk.Widget parent); + public void set_parent_window (Gdk.Window parent_window); + public void set_realized (bool realized); + public void set_receives_default (bool receives_default); + public void set_redraw_on_allocate (bool redraw_on_allocate); + public bool set_scroll_adjustments (Gtk.Adjustment? hadjustment, Gtk.Adjustment? vadjustment); + public void set_sensitive (bool sensitive); + public void set_size_request (int width, int height); + public void set_state (Gtk.StateType state); + public void set_style (Gtk.Style? style); + public void set_tooltip_markup (string markup); + public void set_tooltip_text (string text); + public void set_tooltip_window (Gtk.Window custom_window); + public void set_visible (bool visible); + public void set_window (Gdk.Window window); + public void shape_combine_mask (Gdk.Bitmap? shape_mask, int offset_x, int offset_y); + public virtual void show_all (); + public void show_now (); + public void style_attach (); + public void style_get (...); + public void style_get_property (string property_name, out GLib.Value value); + public void style_get_valist (string first_property_name, void* var_args); + public void thaw_child_notify (); + public bool translate_coordinates (Gtk.Widget dest_widget, int src_x, int src_y, out int dest_x, out int dest_y); + public void trigger_tooltip_query (); + public void unparent (); + [CCode (cname = "GTK_WIDGET_UNSET_FLAGS")] + public void unset_flags (Gtk.WidgetFlags flags); + public bool app_paintable { get; set; } + public bool can_default { get; set; } + [NoAccessorMethod] + public bool can_focus { get; set; } + [NoAccessorMethod] + public bool composite_child { get; } + public bool double_buffered { get; set; } + public Gdk.EventMask events { get; set; } + public Gdk.ExtensionMode extension_events { get; set; } + [NoAccessorMethod] + public bool has_default { get; set; } + [NoAccessorMethod] + public bool has_focus { get; set; } + public bool has_tooltip { get; set; } + [NoAccessorMethod] + public int height_request { get; set; } + [NoAccessorMethod] + public bool is_focus { get; set; } + public string name { get; set; } + public bool no_show_all { get; set; } + public Gtk.Container parent { get; set; } + public bool receives_default { get; set; } + public bool sensitive { get; set; } + public Gtk.Style style { get; set; } + public string tooltip_markup { get; set; } + public string tooltip_text { get; set; } + public bool visible { get; set; } + [NoAccessorMethod] + public int width_request { get; set; } + public virtual signal void accel_closures_changed (); + public virtual signal bool button_press_event (Gdk.EventButton event); + public virtual signal bool button_release_event (Gdk.EventButton event); + [HasEmitter] + public virtual signal bool can_activate_accel (uint signal_id); + [HasEmitter] + public virtual signal void child_notify (GLib.ParamSpec pspec); + public virtual signal bool client_event (Gdk.EventClient event); + public virtual signal void composited_changed (); + public virtual signal bool configure_event (Gdk.EventConfigure event); + public virtual signal bool damage_event (Gdk.Event p0); + public virtual signal bool delete_event (Gdk.Event event); + public virtual signal bool destroy_event (Gdk.Event event); + public virtual signal void direction_changed (Gtk.TextDirection previous_direction); + public virtual signal void drag_begin (Gdk.DragContext context); + public virtual signal void drag_data_delete (Gdk.DragContext context); + public virtual signal void drag_data_get (Gdk.DragContext context, Gtk.SelectionData selection_data, uint info, uint time_); + public virtual signal void drag_data_received (Gdk.DragContext context, int x, int y, Gtk.SelectionData selection_data, uint info, uint time_); + public virtual signal bool drag_drop (Gdk.DragContext context, int x, int y, uint time_); + public virtual signal void drag_end (Gdk.DragContext context); + public virtual signal bool drag_failed (Gdk.DragContext p0, Gtk.DragResult p1); + public virtual signal void drag_leave (Gdk.DragContext context, uint time_); + public virtual signal bool drag_motion (Gdk.DragContext context, int x, int y, uint time_); + public virtual signal bool enter_notify_event (Gdk.EventCrossing event); + [HasEmitter] + public virtual signal bool event (Gdk.Event event); + public virtual signal void event_after (Gdk.Event p0); + public virtual signal bool expose_event (Gdk.EventExpose event); + public virtual signal bool focus (Gtk.DirectionType direction); + public virtual signal bool focus_in_event (Gdk.EventFocus event); + public virtual signal bool focus_out_event (Gdk.EventFocus event); + public virtual signal bool grab_broken_event (Gdk.Event event); + [HasEmitter] + public virtual signal void grab_focus (); + public virtual signal void grab_notify (bool was_grabbed); + [HasEmitter] + public virtual signal void hide (); + public virtual signal void hierarchy_changed (Gtk.Widget? previous_toplevel); + public virtual signal bool key_press_event (Gdk.EventKey event); + public virtual signal bool key_release_event (Gdk.EventKey event); + [HasEmitter] + public virtual signal bool keynav_failed (Gtk.DirectionType p0); + public virtual signal bool leave_notify_event (Gdk.EventCrossing event); + [HasEmitter] + public virtual signal void map (); + public virtual signal bool map_event (Gdk.Event event); + [HasEmitter] + public virtual signal bool mnemonic_activate (bool group_cycling); + public virtual signal bool motion_notify_event (Gdk.EventMotion event); + public virtual signal void move_focus (Gtk.DirectionType p0); + public virtual signal bool no_expose_event (Gdk.EventNoExpose event); + public virtual signal void parent_set (Gtk.Widget? previous_parent); + public virtual signal bool popup_menu (); + public virtual signal bool property_notify_event (Gdk.EventProperty event); + public virtual signal bool proximity_in_event (Gdk.EventProximity event); + public virtual signal bool proximity_out_event (Gdk.EventProximity event); + public virtual signal bool query_tooltip (int x, int y, bool keyboard_tooltip, Gtk.Tooltip tooltip); + [HasEmitter] + public virtual signal void realize (); + public virtual signal void screen_changed (Gdk.Screen previous_screen); + public virtual signal bool scroll_event (Gdk.EventScroll event); + public virtual signal bool selection_clear_event (Gdk.EventSelection event); + public virtual signal void selection_get (Gtk.SelectionData selection_data, uint info, uint time_); + public virtual signal bool selection_notify_event (Gdk.EventSelection event); + public virtual signal void selection_received (Gtk.SelectionData selection_data, uint time_); + public virtual signal bool selection_request_event (Gdk.EventSelection event); + [HasEmitter] + public virtual signal void show (); + public virtual signal bool show_help (Gtk.WidgetHelpType help_type); + [HasEmitter] + public virtual signal void size_allocate (Gdk.Rectangle allocation); + [HasEmitter] + public virtual signal void size_request (out Gtk.Requisition requisition); + public virtual signal void state_changed (Gtk.StateType previous_state); + public virtual signal void style_set (Gtk.Style? previous_style); + [HasEmitter] + public virtual signal void unmap (); + public virtual signal bool unmap_event (Gdk.Event event); + [HasEmitter] + public virtual signal void unrealize (); + public virtual signal bool visibility_notify_event (Gdk.Event event); + public virtual signal bool window_state_event (Gdk.EventWindowState event); + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class WidgetAuxInfo { + public int height; + public int width; + public int x; + public uint x_set; + public int y; + public uint y_set; + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class WidgetShapeInfo { + public int16 offset_x; + public int16 offset_y; + public weak Gdk.Bitmap shape_mask; + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class Window : Gtk.Bin, Atk.Implementor, Gtk.Buildable { + public uint configure_notify_received; + public uint16 configure_request_count; + public weak Gtk.Widget default_widget; + public weak Gtk.Widget focus_widget; + public weak Gdk.Window frame; + public uint frame_bottom; + public uint frame_left; + public uint frame_right; + public uint frame_top; + public weak Gtk.WindowGeometryInfo geometry_info; + public weak Gtk.WindowGroup group; + public uint has_focus; + public uint has_frame; + public uint has_user_ref_count; + public uint iconify_initially; + public uint keys_changed_handler; + public uint maximize_initially; + public Gdk.ModifierType mnemonic_modifier; + public uint need_default_position; + public uint need_default_size; + public uint position; + public uint stick_initially; + public weak Gtk.Window transient_parent; + public weak string wm_role; + public weak string wmclass_class; + public weak string wmclass_name; + [CCode (type = "GtkWidget*", has_construct_function = false)] + public Window (Gtk.WindowType type = Gtk.WindowType.TOPLEVEL); + public bool activate_default (); + public bool activate_focus (); + public bool activate_key (Gdk.EventKey event); + public void add_accel_group (Gtk.AccelGroup accel_group); + public void add_embedded_xid (Gdk.NativeWindow xid); + public void add_mnemonic (uint keyval, Gtk.Widget target); + public void begin_move_drag (int button, int root_x, int root_y, uint32 timestamp); + public void begin_resize_drag (Gdk.WindowEdge edge, int button, int root_x, int root_y, uint32 timestamp); + public void deiconify (); + public void fullscreen (); + public bool get_accept_focus (); + public bool get_decorated (); + public static GLib.List get_default_icon_list (); + public static unowned string get_default_icon_name (); + public void get_default_size (out int width, out int height); + public unowned Gtk.Widget get_default_widget (); + public bool get_deletable (); + public bool get_destroy_with_parent (); + public unowned Gtk.Widget get_focus (); + public bool get_focus_on_map (); + public void get_frame_dimensions (int left, int top, int right, int bottom); + public Gdk.Gravity get_gravity (); + public unowned Gtk.WindowGroup get_group (); + public bool get_has_frame (); + public unowned Gdk.Pixbuf get_icon (); + public GLib.List get_icon_list (); + public unowned string get_icon_name (); + public Gdk.ModifierType get_mnemonic_modifier (); + public bool get_mnemonics_visible (); + public bool get_modal (); + public double get_opacity (); + public void get_position (out int root_x, out int root_y); + public bool get_resizable (); + public unowned string get_role (); + public unowned Gdk.Screen get_screen (); + public void get_size (out int width, out int height); + public bool get_skip_pager_hint (); + public bool get_skip_taskbar_hint (); + public unowned string get_title (); + public unowned Gtk.Window get_transient_for (); + public Gdk.WindowTypeHint get_type_hint (); + public bool get_urgency_hint (); + public Gtk.WindowType get_window_type (); + public void iconify (); + public static GLib.List list_toplevels (); + public void maximize (); + public bool mnemonic_activate (uint keyval, Gdk.ModifierType modifier); + public void move (int x, int y); + [NoWrapper] + public virtual void move_focus (Gtk.DirectionType direction); + public bool parse_geometry (string geometry); + public void present (); + public void present_with_time (uint32 timestamp); + public bool propagate_key_event (Gdk.EventKey event); + public void remove_accel_group (Gtk.AccelGroup accel_group); + public void remove_embedded_xid (Gdk.NativeWindow xid); + public void remove_mnemonic (uint keyval, Gtk.Widget target); + public void reshow_with_initial_size (); + public void resize (int width, int height); + public void set_accept_focus (bool setting); + public static void set_auto_startup_notification (bool setting); + public void set_decorated (bool setting); + public void set_default (Gtk.Widget default_widget); + public static void set_default_icon (Gdk.Pixbuf icon); + public static bool set_default_icon_from_file (string filename) throws GLib.Error; + public static void set_default_icon_list (GLib.List list); + public static void set_default_icon_name (string name); + public void set_default_size (int width, int height); + public void set_deletable (bool setting); + public void set_destroy_with_parent (bool setting); + public void set_focus_on_map (bool setting); + public void set_frame_dimensions (int left, int top, int right, int bottom); + public void set_geometry_hints (Gtk.Widget geometry_widget, Gdk.Geometry geometry, Gdk.WindowHints geom_mask); + public void set_gravity (Gdk.Gravity gravity); + public void set_has_frame (bool setting); + public void set_icon (Gdk.Pixbuf icon); + public bool set_icon_from_file (string filename) throws GLib.Error; + public void set_icon_list (GLib.List list); + public void set_icon_name (string name); + public void set_keep_above (bool setting); + public void set_keep_below (bool setting); + public void set_mnemonic_modifier (Gdk.ModifierType modifier); + public void set_mnemonics_visible (bool setting); + public void set_modal (bool modal); + public void set_opacity (double opacity); + public void set_position (Gtk.WindowPosition position); + public void set_resizable (bool resizable); + public void set_role (string role); + public void set_screen (Gdk.Screen screen); + public void set_skip_pager_hint (bool setting); + public void set_skip_taskbar_hint (bool setting); + public void set_startup_id (string startup_id); + public void set_title (string title); + public void set_transient_for (Gtk.Window parent); + public void set_type_hint (Gdk.WindowTypeHint hint); + public void set_urgency_hint (bool setting); + public void set_wmclass (string wmclass_name, string wmclass_class); + public void stick (); + public void unfullscreen (); + public void unmaximize (); + public void unstick (); + public bool accept_focus { get; set; } + [NoAccessorMethod] + public bool allow_grow { get; set; } + [NoAccessorMethod] + public bool allow_shrink { get; set; } + public bool decorated { get; set; } + [NoAccessorMethod] + public int default_height { get; set; } + [NoAccessorMethod] + public int default_width { get; set; } + public bool deletable { get; set; } + public bool destroy_with_parent { get; set; } + public bool focus_on_map { get; set; } + public Gdk.Gravity gravity { get; set; } + [NoAccessorMethod] + public bool has_toplevel_focus { get; } + public Gdk.Pixbuf icon { get; set; } + public string icon_name { get; set; } + [NoAccessorMethod] + public bool is_active { get; } + public bool mnemonics_visible { get; set; } + public bool modal { get; set; } + public double opacity { get; set; } + public bool resizable { get; set; } + public string role { get; set; } + public Gdk.Screen screen { get; set; } + public bool skip_pager_hint { get; set; } + public bool skip_taskbar_hint { get; set; } + public string startup_id { set; } + public string title { get; set; } + public Gtk.Window transient_for { get; set construct; } + [NoAccessorMethod] + public Gtk.WindowType type { get; construct; } + public Gdk.WindowTypeHint type_hint { get; set; } + public bool urgency_hint { get; set; } + [NoAccessorMethod] + public Gtk.WindowPosition window_position { get; set; } + [Experimental] + public virtual signal void default_activated (); + [Experimental] + public virtual signal void focus_activated (); + public virtual signal bool frame_event (Gdk.Event event); + public virtual signal void keys_changed (); + [HasEmitter] + public virtual signal void set_focus (Gtk.Widget? focus); + } + [Compact] + [CCode (cheader_filename = "gtk/gtk.h")] + public class WindowGeometryInfo { + } + [CCode (cheader_filename = "gtk/gtk.h")] + public class WindowGroup : GLib.Object { + public weak GLib.SList grabs; + [CCode (has_construct_function = false)] + public WindowGroup (); + public void add_window (Gtk.Window window); + public GLib.List list_windows (); + public void remove_window (Gtk.Window window); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public interface Activatable : GLib.Object { + public void do_set_related_action (Gtk.Action action); + public unowned Gtk.Action get_related_action (); + public bool get_use_action_appearance (); + public void set_related_action (Gtk.Action action); + public void set_use_action_appearance (bool use_appearance); + public abstract void sync_action_properties (Gtk.Action action); + [NoWrapper] + public abstract void update (Gtk.Action action, string property_name); + public Gtk.Action related_action { get; set; } + public bool use_action_appearance { get; set; } + } + [CCode (cheader_filename = "gtk/gtk.h")] + public interface Buildable { + public abstract void add_child (Gtk.Builder builder, GLib.Object child, string? type); + public abstract unowned GLib.Object construct_child (Gtk.Builder builder, string name); + public abstract void custom_finished (Gtk.Builder builder, GLib.Object? child, string tagname, void* data); + public abstract void custom_tag_end (Gtk.Builder builder, GLib.Object? child, string tagname, out void* data); + public abstract bool custom_tag_start (Gtk.Builder builder, GLib.Object? child, string tagname, out GLib.MarkupParser parser, out void* data); + public abstract unowned GLib.Object get_internal_child (Gtk.Builder builder, string childname); + public abstract unowned string get_name (); + public abstract void parser_finished (Gtk.Builder builder); + public abstract void set_buildable_property (Gtk.Builder builder, string name, GLib.Value value); + public abstract void set_name (string name); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public interface CellEditable : Gtk.Widget { + public abstract void start_editing (Gdk.Event event); + public bool editing_canceled { get; set; } + [HasEmitter] + public signal void editing_done (); + [HasEmitter] + public signal void remove_widget (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public interface CellLayout : GLib.Object { + public abstract void add_attribute (Gtk.CellRenderer cell, string attribute, int column); + public abstract void clear (); + public abstract void clear_attributes (Gtk.CellRenderer cell); + public abstract GLib.List get_cells (); + public abstract void pack_end (Gtk.CellRenderer cell, bool expand); + public abstract void pack_start (Gtk.CellRenderer cell, bool expand); + public abstract void reorder (Gtk.CellRenderer cell, int position); + public void set_attributes (Gtk.CellRenderer cell, ...); + public abstract void set_cell_data_func (Gtk.CellRenderer cell, owned Gtk.CellLayoutDataFunc func); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public interface Editable { + public void copy_clipboard (); + public void cut_clipboard (); + public void delete_selection (); + [NoWrapper] + public abstract void do_delete_text (int start_pos, int end_pos); + [NoWrapper] + public abstract void do_insert_text (string text, int length, int position); + public abstract unowned string get_chars (int start_pos, int end_pos); + public bool get_editable (); + public abstract int get_position (); + public abstract bool get_selection_bounds (out int start_pos, out int end_pos); + public void paste_clipboard (); + [CCode (vfunc_name = "set_selection_bounds")] + public abstract void select_region (int start_pos, int end_pos); + public void set_editable (bool is_editable); + public abstract void set_position (int position); + public signal void changed (); + [HasEmitter] + public signal void delete_text (int start_pos, int end_pos); + [HasEmitter] + public signal void insert_text (string text, int length, void* position); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public interface FileChooser : Gtk.Widget { + public void add_filter (Gtk.FileFilter filter); + public bool add_shortcut_folder (string folder) throws GLib.Error; + public bool add_shortcut_folder_uri (string uri) throws GLib.Error; + public static GLib.Quark error_quark (); + public Gtk.FileChooserAction get_action (); + public bool get_create_folders (); + public string get_current_folder (); + public unowned GLib.File get_current_folder_file (); + public string get_current_folder_uri (); + public bool get_do_overwrite_confirmation (); + public unowned Gtk.Widget get_extra_widget (); + public unowned GLib.File get_file (); + public string get_filename (); + public GLib.SList get_filenames (); + public GLib.SList get_files (); + public unowned Gtk.FileFilter get_filter (); + public bool get_local_only (); + public unowned GLib.File get_preview_file (); + public string get_preview_filename (); + public string get_preview_uri (); + public unowned Gtk.Widget get_preview_widget (); + public bool get_preview_widget_active (); + public bool get_select_multiple (); + public bool get_show_hidden (); + public string get_uri (); + public GLib.SList get_uris (); + public bool get_use_preview_label (); + public GLib.SList list_filters (); + public GLib.SList? list_shortcut_folder_uris (); + public GLib.SList? list_shortcut_folders (); + public void remove_filter (Gtk.FileFilter filter); + public bool remove_shortcut_folder (string folder) throws GLib.Error; + public bool remove_shortcut_folder_uri (string uri) throws GLib.Error; + public void select_all (); + public bool select_file (GLib.File file) throws GLib.Error; + public bool select_filename (string filename); + public bool select_uri (string uri); + public void set_action (Gtk.FileChooserAction action); + public void set_create_folders (bool create_folders); + public bool set_current_folder (string filename); + public bool set_current_folder_file (GLib.File file) throws GLib.Error; + public bool set_current_folder_uri (string uri); + public void set_current_name (string name); + public void set_do_overwrite_confirmation (bool do_overwrite_confirmation); + public void set_extra_widget (Gtk.Widget extra_widget); + public bool set_file (GLib.File file) throws GLib.Error; + public bool set_filename (string filename); + public void set_filter (Gtk.FileFilter filter); + public void set_local_only (bool local_only); + public void set_preview_widget (Gtk.Widget preview_widget); + public void set_preview_widget_active (bool active); + public void set_select_multiple (bool select_multiple); + public void set_show_hidden (bool show_hidden); + public bool set_uri (string uri); + public void set_use_preview_label (bool use_label); + public void unselect_all (); + public void unselect_file (GLib.File file); + public void unselect_filename (string filename); + public void unselect_uri (string uri); + public Gtk.FileChooserAction action { get; set; } + public bool create_folders { get; set; } + public bool do_overwrite_confirmation { get; set; } + public Gtk.Widget extra_widget { get; set; } + public string file_system_backend { construct; } + public Gtk.FileFilter filter { get; set; } + public bool local_only { get; set; } + public Gtk.Widget preview_widget { get; set; } + public bool preview_widget_active { get; set; } + public bool select_multiple { get; set; } + public bool show_hidden { get; set; } + public bool use_preview_label { get; set; } + public signal Gtk.FileChooserConfirmation confirm_overwrite (); + public signal void current_folder_changed (); + public signal void file_activated (); + public signal void selection_changed (); + public signal void update_preview (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public interface FileChooserEmbed { + } + [CCode (cheader_filename = "gtk/gtk.h")] + public interface Orientable { + public Gtk.Orientation get_orientation (); + public void set_orientation (Gtk.Orientation orientation); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public interface PrintOperationPreview : GLib.Object { + public abstract void end_preview (); + public abstract bool is_selected (int page_nr); + public abstract void render_page (int page_nr); + public signal void got_page_size (Gtk.PrintContext context, Gtk.PageSetup page_setup); + public signal void ready (Gtk.PrintContext context); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public interface RecentChooser : GLib.Object { + public abstract void add_filter (Gtk.RecentFilter filter); + public static GLib.Quark error_quark (); + public unowned Gtk.RecentInfo get_current_item (); + public abstract unowned string get_current_uri (); + public unowned Gtk.RecentFilter get_filter (); + public abstract GLib.List get_items (); + public int get_limit (); + public bool get_local_only (); + [NoWrapper] + public abstract unowned Gtk.RecentManager get_recent_manager (); + public bool get_select_multiple (); + public bool get_show_icons (); + public bool get_show_not_found (); + public bool get_show_private (); + public bool get_show_tips (); + public Gtk.RecentSortType get_sort_type (); + public unowned string get_uris (size_t length); + public abstract GLib.SList list_filters (); + public abstract void remove_filter (Gtk.RecentFilter filter); + public abstract void select_all (); + public abstract bool select_uri (string uri) throws GLib.Error; + public abstract bool set_current_uri (string uri) throws GLib.Error; + public void set_filter (Gtk.RecentFilter filter); + public void set_limit (int limit); + public void set_local_only (bool local_only); + public void set_select_multiple (bool select_multiple); + public void set_show_icons (bool show_icons); + public void set_show_not_found (bool show_not_found); + public void set_show_private (bool show_private); + public void set_show_tips (bool show_tips); + public abstract void set_sort_func (owned Gtk.RecentSortFunc sort_func); + public void set_sort_type (Gtk.RecentSortType sort_type); + public abstract void unselect_all (); + public abstract void unselect_uri (string uri); + public Gtk.RecentFilter filter { get; set; } + public int limit { get; set; } + public bool local_only { get; set; } + public Gtk.RecentManager recent_manager { construct; } + public bool select_multiple { get; set; } + public bool show_icons { get; set; } + public bool show_not_found { get; set; } + public bool show_private { get; set; } + public bool show_tips { get; set; } + public Gtk.RecentSortType sort_type { get; set; } + public signal void item_activated (); + public signal void selection_changed (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public interface ToolShell : Gtk.Widget { + public abstract Pango.EllipsizeMode get_ellipsize_mode (); + public abstract Gtk.IconSize get_icon_size (); + public abstract Gtk.Orientation get_orientation (); + public abstract Gtk.ReliefStyle get_relief_style (); + public abstract Gtk.ToolbarStyle get_style (); + public abstract float get_text_alignment (); + public abstract Gtk.Orientation get_text_orientation (); + public abstract unowned Gtk.SizeGroup get_text_size_group (); + public abstract void rebuild_menu (); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public interface TreeDragDest { + public abstract bool drag_data_received (Gtk.TreePath dest, Gtk.SelectionData selection_data); + public abstract bool row_drop_possible (Gtk.TreePath dest_path, Gtk.SelectionData selection_data); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public interface TreeDragSource { + public abstract bool drag_data_delete (Gtk.TreePath path); + public abstract bool drag_data_get (Gtk.TreePath path, Gtk.SelectionData selection_data); + public abstract bool row_draggable (Gtk.TreePath path); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public interface TreeModel : GLib.Object { + public void @foreach (Gtk.TreeModelForeachFunc func); + [CCode (sentinel = "-1")] + public void @get (Gtk.TreeIter iter, ...); + public abstract GLib.Type get_column_type (int index_); + public abstract Gtk.TreeModelFlags get_flags (); + public abstract bool get_iter (out Gtk.TreeIter iter, Gtk.TreePath path); + public bool get_iter_first (out Gtk.TreeIter iter); + public bool get_iter_from_string (out Gtk.TreeIter iter, string path_string); + public abstract int get_n_columns (); + public abstract Gtk.TreePath? get_path (Gtk.TreeIter iter); + public string get_string_from_iter (Gtk.TreeIter iter); + public void get_valist (Gtk.TreeIter iter, void* var_args); + public abstract void get_value (Gtk.TreeIter iter, int column, out GLib.Value value); + public abstract bool iter_children (out Gtk.TreeIter iter, Gtk.TreeIter? parent); + public abstract bool iter_has_child (Gtk.TreeIter iter); + public abstract int iter_n_children (Gtk.TreeIter? iter); + public abstract bool iter_next (ref Gtk.TreeIter iter); + public abstract bool iter_nth_child (out Gtk.TreeIter iter, Gtk.TreeIter? parent, int n); + public abstract bool iter_parent (out Gtk.TreeIter iter, Gtk.TreeIter child); + public virtual void ref_node (Gtk.TreeIter iter); + public virtual void unref_node (Gtk.TreeIter iter); + [HasEmitter] + public signal void row_changed (Gtk.TreePath path, Gtk.TreeIter iter); + [HasEmitter] + public signal void row_deleted (Gtk.TreePath path); + [HasEmitter] + public signal void row_has_child_toggled (Gtk.TreePath path, Gtk.TreeIter iter); + [HasEmitter] + public signal void row_inserted (Gtk.TreePath path, Gtk.TreeIter iter); + [HasEmitter] + public signal void rows_reordered (Gtk.TreePath path, Gtk.TreeIter? iter, void* new_order); + } + [CCode (cheader_filename = "gtk/gtk.h")] + public interface TreeSortable : Gtk.TreeModel, GLib.Object { + public abstract bool get_sort_column_id (out int sort_column_id, out Gtk.SortType order); + public abstract bool has_default_sort_func (); + public abstract void set_default_sort_func (owned Gtk.TreeIterCompareFunc sort_func); + public abstract void set_sort_column_id (int sort_column_id, Gtk.SortType order); + public abstract void set_sort_func (int sort_column_id, owned Gtk.TreeIterCompareFunc sort_func); + [HasEmitter] + public signal void sort_column_changed (); + } + [CCode (type_id = "GTK_TYPE_ACCEL_KEY", cheader_filename = "gtk/gtk.h")] + public struct AccelKey { + public uint accel_key; + public Gdk.ModifierType accel_mods; + public uint accel_flags; + } + [CCode (type_id = "GTK_TYPE_ACTION_ENTRY", cheader_filename = "gtk/gtk.h")] + public struct ActionEntry { + public weak string name; + public weak string stock_id; + public weak string label; + public weak string accelerator; + public weak string tooltip; + [CCode (type = "GCallback", delegate_target = false)] + public weak Gtk.ActionCallback callback; + } + [CCode (type_id = "GTK_TYPE_ALLOCATION", cheader_filename = "gtk/gtk.h")] + public struct Allocation { + public int x; + public int y; + public int width; + public int height; + } + [CCode (type_id = "GTK_TYPE_IM_CONTEXT_INFO", cheader_filename = "gtk/gtk.h")] + public struct IMContextInfo { + public weak string context_id; + public weak string context_name; + public weak string domain; + public weak string domain_dirname; + public weak string default_locales; + } + [CCode (type_id = "GTK_TYPE_RADIO_ACTION_ENTRY", cheader_filename = "gtk/gtk.h")] + public struct RadioActionEntry { + public weak string name; + public weak string stock_id; + public weak string label; + public weak string accelerator; + public weak string tooltip; + public int value; + } + [CCode (type_id = "GTK_TYPE_RECENT_DATA", has_copy_function = false, has_destroy_function = false, cheader_filename = "gtk/gtk.h")] + public struct RecentData { + public string display_name; + public string description; + public string mime_type; + public string app_name; + public string app_exec; + [CCode (array_length = false, array_null_terminated = true)] + public string[] groups; + public bool is_private; + } + [CCode (type_id = "GTK_TYPE_REQUISITION", cheader_filename = "gtk/gtk.h")] + public struct Requisition { + public int width; + public int height; + public Gtk.Requisition copy (); + public void free (); + } + [CCode (type_id = "GTK_TYPE_STOCK_ITEM", cheader_filename = "gtk/gtk.h")] + public struct StockItem { + public weak string stock_id; + public weak string label; + public Gdk.ModifierType modifier; + public uint keyval; + public weak string translation_domain; + public Gtk.StockItem copy (); + public void free (); + } + [CCode (type_id = "GTK_TYPE_TARGET_ENTRY", cheader_filename = "gtk/gtk.h")] + public struct TargetEntry { + public weak string target; + public uint flags; + public uint info; + } + [CCode (type_id = "GTK_TYPE_TEXT_ITER", cheader_filename = "gtk/gtk.h")] + public struct TextIter { + public void* dummy1; + public void* dummy2; + public int dummy3; + public int dummy4; + public int dummy5; + public int dummy6; + public int dummy7; + public int dummy8; + public void* dummy9; + public void* dummy10; + public int dummy11; + public int dummy12; + public int dummy13; + public void* dummy14; + public bool backward_char (); + public bool backward_chars (int count); + public bool backward_cursor_position (); + public bool backward_cursor_positions (int count); + public bool backward_find_char (Gtk.TextCharPredicate pred, Gtk.TextIter limit); + public bool backward_line (); + public bool backward_lines (int count); + public bool backward_search (string str, Gtk.TextSearchFlags flags, out Gtk.TextIter match_start, out Gtk.TextIter match_end, Gtk.TextIter? limit); + public bool backward_sentence_start (); + public bool backward_sentence_starts (int count); + public bool backward_to_tag_toggle (Gtk.TextTag? tag); + public bool backward_visible_cursor_position (); + public bool backward_visible_cursor_positions (int count); + public bool backward_visible_line (); + public bool backward_visible_lines (int count); + public bool backward_visible_word_start (); + public bool backward_visible_word_starts (int count); + public bool backward_word_start (); + public bool backward_word_starts (int count); + public bool begins_tag (Gtk.TextTag? tag); + public bool can_insert (bool default_editability); + public int compare (Gtk.TextIter rhs); + public Gtk.TextIter copy (); + public bool editable (bool default_setting); + public bool ends_line (); + public bool ends_sentence (); + public bool ends_tag (Gtk.TextTag? tag); + public bool ends_word (); + public bool equal (Gtk.TextIter rhs); + public bool forward_char (); + public bool forward_chars (int count); + public bool forward_cursor_position (); + public bool forward_cursor_positions (int count); + public bool forward_find_char (Gtk.TextCharPredicate pred, Gtk.TextIter? limit); + public bool forward_line (); + public bool forward_lines (int count); + public bool forward_search (string str, Gtk.TextSearchFlags flags, out Gtk.TextIter match_start, out Gtk.TextIter match_end, Gtk.TextIter? limit); + public bool forward_sentence_end (); + public bool forward_sentence_ends (int count); + public void forward_to_end (); + public bool forward_to_line_end (); + public bool forward_to_tag_toggle (Gtk.TextTag? tag); + public bool forward_visible_cursor_position (); + public bool forward_visible_cursor_positions (int count); + public bool forward_visible_line (); + public bool forward_visible_lines (int count); + public bool forward_visible_word_end (); + public bool forward_visible_word_ends (int count); + public bool forward_word_end (); + public bool forward_word_ends (int count); + public void free (); + public bool get_attributes (Gtk.TextAttributes values); + public unowned Gtk.TextBuffer get_buffer (); + public int get_bytes_in_line (); + public unichar get_char (); + public int get_chars_in_line (); + public unowned Gtk.TextChildAnchor get_child_anchor (); + public unowned Pango.Language get_language (); + public int get_line (); + public int get_line_index (); + public int get_line_offset (); + public GLib.SList get_marks (); + public int get_offset (); + public unowned Gdk.Pixbuf get_pixbuf (); + public unowned string get_slice (Gtk.TextIter end); + public GLib.SList get_tags (); + public unowned string get_text (Gtk.TextIter end); + public GLib.SList get_toggled_tags (bool toggled_on); + public int get_visible_line_index (); + public int get_visible_line_offset (); + public unowned string get_visible_slice (Gtk.TextIter end); + public unowned string get_visible_text (Gtk.TextIter end); + public bool has_tag (Gtk.TextTag tag); + public bool in_range (Gtk.TextIter start, Gtk.TextIter end); + public bool inside_sentence (); + public bool inside_word (); + public bool is_cursor_position (); + public bool is_end (); + public bool is_start (); + public void order (Gtk.TextIter second); + public void set_line (int line_number); + public void set_line_index (int byte_on_line); + public void set_line_offset (int char_on_line); + public void set_offset (int char_offset); + public void set_visible_line_index (int byte_on_line); + public void set_visible_line_offset (int char_on_line); + public bool starts_line (); + public bool starts_sentence (); + public bool starts_word (); + public bool toggles_tag (Gtk.TextTag tag); + } + [CCode (type_id = "GTK_TYPE_TOGGLE_ACTION_ENTRY", cheader_filename = "gtk/gtk.h")] + public struct ToggleActionEntry { + public weak string name; + public weak string stock_id; + public weak string label; + public weak string accelerator; + public weak string tooltip; + [CCode (type = "GCallback", delegate_target = false)] + public weak Gtk.ActionCallback callback; + public bool is_active; + } + [CCode (type_id = "GTK_TYPE_TREE_ITER", cheader_filename = "gtk/gtk.h")] + public struct TreeIter { + public int stamp; + public void* user_data; + public void* user_data2; + public void* user_data3; + } + [CCode (cprefix = "GTK_ACCEL_", cheader_filename = "gtk/gtk.h")] + [Flags] + public enum AccelFlags { + VISIBLE, + LOCKED, + MASK + } + [CCode (cprefix = "GTK_ANCHOR_", cheader_filename = "gtk/gtk.h")] + public enum AnchorType { + CENTER, + NORTH, + NORTH_WEST, + NORTH_EAST, + SOUTH, + SOUTH_WEST, + SOUTH_EAST, + WEST, + EAST, + N, + NW, + NE, + S, + SW, + SE, + W, + E + } + [CCode (cprefix = "GTK_ARG_", cheader_filename = "gtk/gtk.h")] + [Flags] + public enum ArgFlags { + READABLE, + WRITABLE, + CONSTRUCT, + CONSTRUCT_ONLY, + CHILD_ARG + } + [CCode (cprefix = "GTK_ARROWS_", cheader_filename = "gtk/gtk.h")] + public enum ArrowPlacement { + BOTH, + START, + END + } + [CCode (cprefix = "GTK_ARROW_", cheader_filename = "gtk/gtk.h")] + public enum ArrowType { + UP, + DOWN, + LEFT, + RIGHT, + NONE + } + [CCode (cprefix = "GTK_ASSISTANT_PAGE_", cheader_filename = "gtk/gtk.h")] + public enum AssistantPageType { + CONTENT, + INTRO, + CONFIRM, + SUMMARY, + PROGRESS + } + [CCode (cprefix = "GTK_", cheader_filename = "gtk/gtk.h")] + [Flags] + public enum AttachOptions { + EXPAND, + SHRINK, + FILL + } + [CCode (cprefix = "GTK_BUTTON_", cheader_filename = "gtk/gtk.h")] + [Flags] + public enum ButtonAction { + IGNORED, + SELECTS, + DRAGS, + EXPANDS + } + [CCode (cprefix = "GTK_BUTTONBOX_", cheader_filename = "gtk/gtk.h")] + public enum ButtonBoxStyle { + DEFAULT_STYLE, + SPREAD, + EDGE, + START, + END, + CENTER + } + [CCode (cprefix = "GTK_BUTTONS_", cheader_filename = "gtk/gtk.h")] + public enum ButtonsType { + NONE, + OK, + CLOSE, + CANCEL, + YES_NO, + OK_CANCEL + } + [CCode (cprefix = "GTK_CLIST_DRAG_", cheader_filename = "gtk/gtk.h")] + public enum CListDragPos { + NONE, + BEFORE, + INTO, + AFTER + } + [CCode (cprefix = "GTK_CTREE_EXPANDER_", cheader_filename = "gtk/gtk.h")] + public enum CTreeExpanderStyle { + NONE, + SQUARE, + TRIANGLE, + CIRCULAR + } + [CCode (cprefix = "GTK_CTREE_EXPANSION_", cheader_filename = "gtk/gtk.h")] + public enum CTreeExpansionType { + EXPAND, + EXPAND_RECURSIVE, + COLLAPSE, + COLLAPSE_RECURSIVE, + TOGGLE, + TOGGLE_RECURSIVE + } + [CCode (cprefix = "GTK_CTREE_LINES_", cheader_filename = "gtk/gtk.h")] + public enum CTreeLineStyle { + NONE, + SOLID, + DOTTED, + TABBED + } + [CCode (cprefix = "GTK_CTREE_POS_", cheader_filename = "gtk/gtk.h")] + public enum CTreePos { + BEFORE, + AS_CHILD, + AFTER + } + [CCode (cprefix = "GTK_CALENDAR_", cheader_filename = "gtk/gtk.h")] + [Flags] + public enum CalendarDisplayOptions { + SHOW_HEADING, + SHOW_DAY_NAMES, + NO_MONTH_CHANGE, + SHOW_WEEK_NUMBERS, + WEEK_START_MONDAY, + SHOW_DETAILS + } + [CCode (cprefix = "GTK_CELL_RENDERER_ACCEL_MODE_", cheader_filename = "gtk/gtk.h")] + public enum CellRendererAccelMode { + GTK, + OTHER + } + [CCode (cprefix = "GTK_CELL_RENDERER_MODE_", cheader_filename = "gtk/gtk.h")] + public enum CellRendererMode { + INERT, + ACTIVATABLE, + EDITABLE + } + [CCode (cprefix = "GTK_CELL_RENDERER_", cheader_filename = "gtk/gtk.h")] + [Flags] + public enum CellRendererState { + SELECTED, + PRELIT, + INSENSITIVE, + SORTED, + FOCUSED + } + [CCode (cprefix = "GTK_CELL_", cheader_filename = "gtk/gtk.h")] + public enum CellType { + EMPTY, + TEXT, + PIXMAP, + PIXTEXT, + WIDGET + } + [CCode (cprefix = "GTK_CORNER_", cheader_filename = "gtk/gtk.h")] + public enum CornerType { + TOP_LEFT, + BOTTOM_LEFT, + TOP_RIGHT, + BOTTOM_RIGHT + } + [CCode (cprefix = "GTK_CURVE_TYPE_", cheader_filename = "gtk/gtk.h")] + public enum CurveType { + LINEAR, + SPLINE, + FREE + } + [CCode (cprefix = "GTK_DEBUG_", cheader_filename = "gtk/gtk.h")] + [Flags] + public enum DebugFlag { + MISC, + PLUGSOCKET, + TEXT, + TREE, + UPDATES, + KEYBINDINGS, + MULTIHEAD, + MODULES, + GEOMETRY, + ICONTHEME, + PRINTING, + BUILDER + } + [CCode (cprefix = "GTK_DELETE_", cheader_filename = "gtk/gtk.h")] + public enum DeleteType { + CHARS, + WORD_ENDS, + WORDS, + DISPLAY_LINES, + DISPLAY_LINE_ENDS, + PARAGRAPH_ENDS, + PARAGRAPHS, + WHITESPACE + } + [CCode (cprefix = "GTK_DEST_DEFAULT_", cheader_filename = "gtk/gtk.h")] + [Flags] + public enum DestDefaults { + MOTION, + HIGHLIGHT, + DROP, + ALL + } + [CCode (cprefix = "GTK_DIALOG_", cheader_filename = "gtk/gtk.h")] + [Flags] + public enum DialogFlags { + MODAL, + DESTROY_WITH_PARENT, + NO_SEPARATOR + } + [CCode (cprefix = "GTK_DIR_", cheader_filename = "gtk/gtk.h")] + public enum DirectionType { + TAB_FORWARD, + TAB_BACKWARD, + UP, + DOWN, + LEFT, + RIGHT + } + [CCode (cprefix = "GTK_DRAG_RESULT_", cheader_filename = "gtk/gtk.h")] + public enum DragResult { + SUCCESS, + NO_TARGET, + USER_CANCELLED, + TIMEOUT_EXPIRED, + GRAB_BROKEN, + ERROR + } + [CCode (cprefix = "GTK_ENTRY_ICON_", cheader_filename = "gtk/gtk.h")] + public enum EntryIconPosition { + PRIMARY, + SECONDARY + } + [CCode (cprefix = "GTK_EXPANDER_", cheader_filename = "gtk/gtk.h")] + public enum ExpanderStyle { + COLLAPSED, + SEMI_COLLAPSED, + SEMI_EXPANDED, + EXPANDED + } + [CCode (cprefix = "GTK_FILE_CHOOSER_ACTION_", cheader_filename = "gtk/gtk.h")] + public enum FileChooserAction { + OPEN, + SAVE, + SELECT_FOLDER, + CREATE_FOLDER + } + [CCode (cprefix = "GTK_FILE_CHOOSER_CONFIRMATION_", cheader_filename = "gtk/gtk.h")] + public enum FileChooserConfirmation { + CONFIRM, + ACCEPT_FILENAME, + SELECT_AGAIN + } + [CCode (cprefix = "GTK_FILE_CHOOSER_ERROR_", cheader_filename = "gtk/gtk.h")] + public enum FileChooserError { + NONEXISTENT, + BAD_FILENAME, + ALREADY_EXISTS, + INCOMPLETE_HOSTNAME + } + [CCode (cprefix = "GTK_FILE_FILTER_", cheader_filename = "gtk/gtk.h")] + [Flags] + public enum FileFilterFlags { + FILENAME, + URI, + DISPLAY_NAME, + MIME_TYPE + } + [CCode (cprefix = "GTK_IM_PREEDIT_", cheader_filename = "gtk/gtk.h")] + public enum IMPreeditStyle { + NOTHING, + CALLBACK, + NONE + } + [CCode (cprefix = "GTK_IM_STATUS_", cheader_filename = "gtk/gtk.h")] + public enum IMStatusStyle { + NOTHING, + CALLBACK, + NONE + } + [CCode (cprefix = "GTK_ICON_LOOKUP_", cheader_filename = "gtk/gtk.h")] + [Flags] + public enum IconLookupFlags { + NO_SVG, + FORCE_SVG, + USE_BUILTIN, + GENERIC_FALLBACK, + FORCE_SIZE + } + [CCode (cprefix = "GTK_ICON_SIZE_", cheader_filename = "gtk/gtk.h")] + public enum IconSize { + INVALID, + MENU, + SMALL_TOOLBAR, + LARGE_TOOLBAR, + BUTTON, + DND, + DIALOG + } + [CCode (cprefix = "GTK_ICON_THEME_", cheader_filename = "gtk/gtk.h")] + public enum IconThemeError { + NOT_FOUND, + FAILED + } + [CCode (cprefix = "GTK_ICON_VIEW_", cheader_filename = "gtk/gtk.h")] + public enum IconViewDropPosition { + NO_DROP, + DROP_INTO, + DROP_LEFT, + DROP_RIGHT, + DROP_ABOVE, + DROP_BELOW + } + [CCode (cprefix = "GTK_IMAGE_", cheader_filename = "gtk/gtk.h")] + public enum ImageType { + EMPTY, + PIXMAP, + IMAGE, + PIXBUF, + STOCK, + ICON_SET, + ANIMATION, + ICON_NAME, + GICON + } + [CCode (cprefix = "GTK_JUSTIFY_", cheader_filename = "gtk/gtk.h")] + public enum Justification { + LEFT, + RIGHT, + CENTER, + FILL + } + [CCode (cprefix = "GTK_MATCH_", cheader_filename = "gtk/gtk.h")] + public enum MatchType { + ALL, + ALL_TAIL, + HEAD, + TAIL, + EXACT, + LAST + } + [CCode (cprefix = "GTK_MENU_DIR_", cheader_filename = "gtk/gtk.h")] + public enum MenuDirectionType { + PARENT, + CHILD, + NEXT, + PREV + } + [CCode (cprefix = "GTK_MESSAGE_", cheader_filename = "gtk/gtk.h")] + public enum MessageType { + INFO, + WARNING, + QUESTION, + ERROR, + OTHER + } + [CCode (cprefix = "GTK_", cheader_filename = "gtk/gtk.h")] + public enum MetricType { + PIXELS, + INCHES, + CENTIMETERS + } + [CCode (cprefix = "GTK_MOVEMENT_", cheader_filename = "gtk/gtk.h")] + public enum MovementStep { + LOGICAL_POSITIONS, + VISUAL_POSITIONS, + WORDS, + DISPLAY_LINES, + DISPLAY_LINE_ENDS, + PARAGRAPHS, + PARAGRAPH_ENDS, + PAGES, + BUFFER_ENDS, + HORIZONTAL_PAGES + } + [CCode (cprefix = "GTK_NOTEBOOK_TAB_", cheader_filename = "gtk/gtk.h")] + public enum NotebookTab { + FIRST, + LAST + } + [CCode (cprefix = "GTK_NUMBER_UP_LAYOUT_", cheader_filename = "gtk/gtk.h")] + public enum NumberUpLayout { + LEFT_TO_RIGHT_TOP_TO_BOTTOM, + LEFT_TO_RIGHT_BOTTOM_TO_TOP, + RIGHT_TO_LEFT_TOP_TO_BOTTOM, + RIGHT_TO_LEFT_BOTTOM_TO_TOP, + TOP_TO_BOTTOM_LEFT_TO_RIGHT, + TOP_TO_BOTTOM_RIGHT_TO_LEFT, + BOTTOM_TO_TOP_LEFT_TO_RIGHT, + BOTTOM_TO_TOP_RIGHT_TO_LEFT + } + [CCode (cprefix = "GTK_", cheader_filename = "gtk/gtk.h")] + [Flags] + public enum ObjectFlags { + IN_DESTRUCTION, + FLOATING, + RESERVED_1, + RESERVED_2 + } + [CCode (cprefix = "GTK_ORIENTATION_", cheader_filename = "gtk/gtk.h")] + public enum Orientation { + HORIZONTAL, + VERTICAL + } + [CCode (cprefix = "GTK_PACK_DIRECTION_", cheader_filename = "gtk/gtk.h")] + public enum PackDirection { + LTR, + RTL, + TTB, + BTT + } + [CCode (cprefix = "GTK_PACK_", cheader_filename = "gtk/gtk.h")] + public enum PackType { + START, + END + } + [CCode (cprefix = "GTK_PAGE_ORIENTATION_", cheader_filename = "gtk/gtk.h")] + public enum PageOrientation { + PORTRAIT, + LANDSCAPE, + REVERSE_PORTRAIT, + REVERSE_LANDSCAPE + } + [CCode (cprefix = "GTK_PAGE_SET_", cheader_filename = "gtk/gtk.h")] + public enum PageSet { + ALL, + EVEN, + ODD + } + [CCode (cprefix = "GTK_PATH_PRIO_", cheader_filename = "gtk/gtk.h")] + public enum PathPriorityType { + LOWEST, + GTK, + APPLICATION, + THEME, + RC, + HIGHEST + } + [CCode (cprefix = "GTK_PATH_", cheader_filename = "gtk/gtk.h")] + public enum PathType { + WIDGET, + WIDGET_CLASS, + CLASS + } + [CCode (cprefix = "GTK_POLICY_", cheader_filename = "gtk/gtk.h")] + public enum PolicyType { + ALWAYS, + AUTOMATIC, + NEVER + } + [CCode (cprefix = "GTK_POS_", cheader_filename = "gtk/gtk.h")] + public enum PositionType { + LEFT, + RIGHT, + TOP, + BOTTOM + } + [CCode (cprefix = "GTK_PREVIEW_", cheader_filename = "gtk/gtk.h")] + public enum PreviewType { + COLOR, + GRAYSCALE + } + [CCode (cprefix = "GTK_PRINT_DUPLEX_", cheader_filename = "gtk/gtk.h")] + public enum PrintDuplex { + SIMPLEX, + HORIZONTAL, + VERTICAL + } + [CCode (cprefix = "GTK_PRINT_ERROR_", cheader_filename = "gtk/gtk.h")] + public enum PrintError { + GENERAL, + INTERNAL_ERROR, + NOMEM, + INVALID_FILE + } + [CCode (cprefix = "GTK_PRINT_OPERATION_ACTION_", cheader_filename = "gtk/gtk.h")] + public enum PrintOperationAction { + PRINT_DIALOG, + PRINT, + PREVIEW, + EXPORT + } + [CCode (cprefix = "GTK_PRINT_OPERATION_RESULT_", cheader_filename = "gtk/gtk.h")] + public enum PrintOperationResult { + ERROR, + APPLY, + CANCEL, + IN_PROGRESS + } + [CCode (cprefix = "GTK_PRINT_PAGES_", cheader_filename = "gtk/gtk.h")] + public enum PrintPages { + ALL, + CURRENT, + RANGES, + SELECTION + } + [CCode (cprefix = "GTK_PRINT_QUALITY_", cheader_filename = "gtk/gtk.h")] + public enum PrintQuality { + LOW, + NORMAL, + HIGH, + DRAFT + } + [CCode (cprefix = "GTK_PRINT_STATUS_", cheader_filename = "gtk/gtk.h")] + public enum PrintStatus { + INITIAL, + PREPARING, + GENERATING_DATA, + SENDING_DATA, + PENDING, + PENDING_ISSUE, + PRINTING, + FINISHED, + FINISHED_ABORTED + } + [CCode (cprefix = "PRIVATE_GTK_", cheader_filename = "gtk/gtk.h")] + [Flags] + public enum PrivateFlags { + USER_STYLE, + RESIZE_PENDING, + HAS_POINTER, + SHADOWED, + HAS_SHAPE_MASK, + IN_REPARENT, + DIRECTION_SET, + DIRECTION_LTR, + ANCHORED, + CHILD_VISIBLE, + REDRAW_ON_ALLOC, + ALLOC_NEEDED, + REQUEST_NEEDED + } + [CCode (cprefix = "GTK_PROGRESS_", cheader_filename = "gtk/gtk.h")] + public enum ProgressBarOrientation { + LEFT_TO_RIGHT, + RIGHT_TO_LEFT, + BOTTOM_TO_TOP, + TOP_TO_BOTTOM + } + [CCode (cprefix = "GTK_PROGRESS_", cheader_filename = "gtk/gtk.h")] + public enum ProgressBarStyle { + CONTINUOUS, + DISCRETE + } + [CCode (cprefix = "GTK_RC_", cheader_filename = "gtk/gtk.h")] + [Flags] + public enum RcFlags { + FG, + BG, + TEXT, + BASE + } + [CCode (cprefix = "GTK_RC_TOKEN_", cheader_filename = "gtk/gtk.h")] + public enum RcTokenType { + INVALID, + INCLUDE, + NORMAL, + ACTIVE, + PRELIGHT, + SELECTED, + INSENSITIVE, + FG, + BG, + TEXT, + BASE, + XTHICKNESS, + YTHICKNESS, + FONT, + FONTSET, + FONT_NAME, + BG_PIXMAP, + PIXMAP_PATH, + STYLE, + BINDING, + BIND, + WIDGET, + WIDGET_CLASS, + CLASS, + LOWEST, + GTK, + APPLICATION, + THEME, + RC, + HIGHEST, + ENGINE, + MODULE_PATH, + IM_MODULE_PATH, + IM_MODULE_FILE, + STOCK, + LTR, + RTL, + COLOR, + UNBIND, + LAST + } + [CCode (cprefix = "GTK_RECENT_CHOOSER_ERROR_", cheader_filename = "gtk/gtk.h")] + public enum RecentChooserError { + NOT_FOUND, + INVALID_URI + } + [CCode (cprefix = "GTK_RECENT_FILTER_", cheader_filename = "gtk/gtk.h")] + [Flags] + public enum RecentFilterFlags { + URI, + DISPLAY_NAME, + MIME_TYPE, + APPLICATION, + GROUP, + AGE + } + [CCode (cprefix = "GTK_RECENT_MANAGER_ERROR_", cheader_filename = "gtk/gtk.h")] + public enum RecentManagerError { + NOT_FOUND, + INVALID_URI, + INVALID_ENCODING, + NOT_REGISTERED, + READ, + WRITE, + UNKNOWN + } + [CCode (cprefix = "GTK_RECENT_SORT_", cheader_filename = "gtk/gtk.h")] + public enum RecentSortType { + NONE, + MRU, + LRU, + CUSTOM + } + [CCode (cprefix = "GTK_RELIEF_", cheader_filename = "gtk/gtk.h")] + public enum ReliefStyle { + NORMAL, + HALF, + NONE + } + [CCode (cprefix = "GTK_RESIZE_", cheader_filename = "gtk/gtk.h")] + public enum ResizeMode { + PARENT, + QUEUE, + IMMEDIATE + } + [CCode (cprefix = "GTK_RESPONSE_", cheader_filename = "gtk/gtk.h")] + public enum ResponseType { + NONE, + REJECT, + ACCEPT, + DELETE_EVENT, + OK, + CANCEL, + CLOSE, + YES, + NO, + APPLY, + HELP + } + [CCode (cprefix = "GTK_SCROLL_", cheader_filename = "gtk/gtk.h")] + public enum ScrollStep { + STEPS, + PAGES, + ENDS, + HORIZONTAL_STEPS, + HORIZONTAL_PAGES, + HORIZONTAL_ENDS + } + [CCode (cprefix = "GTK_SCROLL_", cheader_filename = "gtk/gtk.h")] + public enum ScrollType { + NONE, + JUMP, + STEP_BACKWARD, + STEP_FORWARD, + PAGE_BACKWARD, + PAGE_FORWARD, + STEP_UP, + STEP_DOWN, + PAGE_UP, + PAGE_DOWN, + STEP_LEFT, + STEP_RIGHT, + PAGE_LEFT, + PAGE_RIGHT, + START, + END + } + [CCode (cprefix = "GTK_SELECTION_", cheader_filename = "gtk/gtk.h")] + public enum SelectionMode { + NONE, + SINGLE, + BROWSE, + MULTIPLE, + EXTENDED + } + [CCode (cprefix = "GTK_SENSITIVITY_", cheader_filename = "gtk/gtk.h")] + public enum SensitivityType { + AUTO, + ON, + OFF + } + [CCode (cprefix = "GTK_SHADOW_", cheader_filename = "gtk/gtk.h")] + public enum ShadowType { + NONE, + IN, + OUT, + ETCHED_IN, + ETCHED_OUT + } + [CCode (cprefix = "GTK_SIDE_", cheader_filename = "gtk/gtk.h")] + public enum SideType { + TOP, + BOTTOM, + LEFT, + RIGHT + } + [CCode (cprefix = "GTK_RUN_", cheader_filename = "gtk/gtk.h")] + [Flags] + public enum SignalRunType { + FIRST, + LAST, + BOTH, + NO_RECURSE, + ACTION, + NO_HOOKS + } + [CCode (cprefix = "GTK_SIZE_GROUP_", cheader_filename = "gtk/gtk.h")] + public enum SizeGroupMode { + NONE, + HORIZONTAL, + VERTICAL, + BOTH + } + [CCode (cprefix = "GTK_SORT_COLUMN_", cname = "gint", cheader_filename = "gtk/gtk.h")] + public enum SortColumn { + [CCode (cname = "GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID")] + DEFAULT, + [CCode (cname = "GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID")] + UNSORTED + } + [CCode (cprefix = "GTK_SORT_", cheader_filename = "gtk/gtk.h")] + public enum SortType { + ASCENDING, + DESCENDING + } + [CCode (cprefix = "GTK_UPDATE_", cheader_filename = "gtk/gtk.h")] + public enum SpinButtonUpdatePolicy { + ALWAYS, + IF_VALID + } + [CCode (cprefix = "GTK_SPIN_", cheader_filename = "gtk/gtk.h")] + public enum SpinType { + STEP_FORWARD, + STEP_BACKWARD, + PAGE_FORWARD, + PAGE_BACKWARD, + HOME, + END, + USER_DEFINED + } + [CCode (cprefix = "GTK_STATE_", cheader_filename = "gtk/gtk.h")] + public enum StateType { + NORMAL, + ACTIVE, + PRELIGHT, + SELECTED, + INSENSITIVE + } + [CCode (cprefix = "GTK_DIRECTION_", cheader_filename = "gtk/gtk.h")] + public enum SubmenuDirection { + LEFT, + RIGHT + } + [CCode (cprefix = "GTK_", cheader_filename = "gtk/gtk.h")] + public enum SubmenuPlacement { + TOP_BOTTOM, + LEFT_RIGHT + } + [CCode (cprefix = "GTK_TARGET_", cheader_filename = "gtk/gtk.h")] + [Flags] + public enum TargetFlags { + SAME_APP, + SAME_WIDGET, + OTHER_APP, + OTHER_WIDGET + } + [CCode (cprefix = "GTK_TEXT_BUFFER_TARGET_INFO_", cheader_filename = "gtk/gtk.h")] + public enum TextBufferTargetInfo { + BUFFER_CONTENTS, + RICH_TEXT, + TEXT + } + [CCode (cprefix = "GTK_TEXT_DIR_", cheader_filename = "gtk/gtk.h")] + public enum TextDirection { + NONE, + LTR, + RTL + } + [CCode (cprefix = "GTK_TEXT_SEARCH_", cheader_filename = "gtk/gtk.h")] + [Flags] + public enum TextSearchFlags { + VISIBLE_ONLY, + TEXT_ONLY + } + [CCode (cprefix = "GTK_TEXT_WINDOW_", cheader_filename = "gtk/gtk.h")] + public enum TextWindowType { + PRIVATE, + WIDGET, + TEXT, + LEFT, + RIGHT, + TOP, + BOTTOM + } + [CCode (cprefix = "GTK_TOOL_PALETTE_DRAG_", cheader_filename = "gtk/gtk.h")] + [Flags] + public enum ToolPaletteDragTargets { + ITEMS, + GROUPS + } + [CCode (cprefix = "GTK_TOOLBAR_CHILD_", cheader_filename = "gtk/gtk.h")] + public enum ToolbarChildType { + SPACE, + BUTTON, + TOGGLEBUTTON, + RADIOBUTTON, + WIDGET + } + [CCode (cprefix = "GTK_TOOLBAR_SPACE_", cheader_filename = "gtk/gtk.h")] + public enum ToolbarSpaceStyle { + EMPTY, + LINE + } + [CCode (cprefix = "GTK_TOOLBAR_", cheader_filename = "gtk/gtk.h")] + public enum ToolbarStyle { + ICONS, + TEXT, + BOTH, + BOTH_HORIZ + } + [CCode (cprefix = "GTK_TREE_MODEL_", cheader_filename = "gtk/gtk.h")] + [Flags] + public enum TreeModelFlags { + ITERS_PERSIST, + LIST_ONLY + } + [CCode (cprefix = "GTK_TREE_VIEW_COLUMN_", cheader_filename = "gtk/gtk.h")] + public enum TreeViewColumnSizing { + GROW_ONLY, + AUTOSIZE, + FIXED + } + [CCode (cprefix = "GTK_TREE_VIEW_DROP_", cheader_filename = "gtk/gtk.h")] + public enum TreeViewDropPosition { + BEFORE, + AFTER, + INTO_OR_BEFORE, + INTO_OR_AFTER + } + [CCode (cprefix = "GTK_TREE_VIEW_GRID_LINES_", cheader_filename = "gtk/gtk.h")] + public enum TreeViewGridLines { + NONE, + HORIZONTAL, + VERTICAL, + BOTH + } + [CCode (cprefix = "GTK_TREE_VIEW_", cheader_filename = "gtk/gtk.h")] + public enum TreeViewMode { + LINE, + ITEM + } + [CCode (cprefix = "GTK_UI_MANAGER_", cheader_filename = "gtk/gtk.h")] + [Flags] + public enum UIManagerItemType { + AUTO, + MENUBAR, + MENU, + TOOLBAR, + PLACEHOLDER, + POPUP, + MENUITEM, + TOOLITEM, + SEPARATOR, + ACCELERATOR, + POPUP_WITH_ACCELS + } + [CCode (cprefix = "GTK_UNIT_", cheader_filename = "gtk/gtk.h")] + public enum Unit { + PIXEL, + POINTS, + INCH, + MM + } + [CCode (cprefix = "GTK_UPDATE_", cheader_filename = "gtk/gtk.h")] + public enum UpdateType { + CONTINUOUS, + DISCONTINUOUS, + DELAYED + } + [CCode (cprefix = "GTK_VISIBILITY_", cheader_filename = "gtk/gtk.h")] + public enum Visibility { + NONE, + PARTIAL, + FULL + } + [CCode (cprefix = "GTK_", cheader_filename = "gtk/gtk.h")] + [Flags] + public enum WidgetFlags { + TOPLEVEL, + NO_WINDOW, + REALIZED, + MAPPED, + VISIBLE, + SENSITIVE, + PARENT_SENSITIVE, + CAN_FOCUS, + HAS_FOCUS, + CAN_DEFAULT, + HAS_DEFAULT, + HAS_GRAB, + RC_STYLE, + COMPOSITE_CHILD, + NO_REPARENT, + APP_PAINTABLE, + RECEIVES_DEFAULT, + DOUBLE_BUFFERED, + NO_SHOW_ALL + } + [CCode (cprefix = "GTK_WIDGET_HELP_", cheader_filename = "gtk/gtk.h")] + public enum WidgetHelpType { + TOOLTIP, + WHATS_THIS + } + [CCode (cprefix = "GTK_WIN_POS_", cheader_filename = "gtk/gtk.h")] + public enum WindowPosition { + NONE, + CENTER, + MOUSE, + CENTER_ALWAYS, + CENTER_ON_PARENT + } + [CCode (cprefix = "GTK_WINDOW_", cheader_filename = "gtk/gtk.h")] + public enum WindowType { + TOPLEVEL, + POPUP + } + [CCode (cprefix = "GTK_WRAP_", cheader_filename = "gtk/gtk.h")] + public enum WrapMode { + NONE, + CHAR, + WORD, + WORD_CHAR + } + [CCode (cprefix = "GTK_BUILDER_ERROR_", cheader_filename = "gtk/gtk.h")] + public errordomain BuilderError { + INVALID_TYPE_FUNCTION, + UNHANDLED_TAG, + MISSING_ATTRIBUTE, + INVALID_ATTRIBUTE, + INVALID_TAG, + MISSING_PROPERTY_VALUE, + INVALID_VALUE, + VERSION_MISMATCH, + DUPLICATE_ID + } + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate void AboutDialogActivateLinkFunc (Gtk.AboutDialog about, string link_); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate bool AccelGroupActivate (Gtk.AccelGroup accel_group, GLib.Object acceleratable, uint keyval, Gdk.ModifierType modifier); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate bool AccelGroupFindFunc (Gtk.AccelKey key, GLib.Closure closure); + [CCode (cheader_filename = "gtk/gtk.h", has_target = false)] + public delegate void AccelMapForeach (void* data, string accel_path, uint accel_key, Gdk.ModifierType accel_mods, bool changed); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate void ActionCallback (Gtk.Action action); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate int AssistantPageFunc (int current_page); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate void BuilderConnectFunc (Gtk.Builder builder, GLib.Object object, string signal_name, string handler_name, GLib.Object connect_object, GLib.ConnectFlags flags); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate string CalendarDetailFunc (Gtk.Calendar calendar, uint year, uint month, uint day); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate void Callback (Gtk.Widget widget); + [CCode (cheader_filename = "gtk/gtk.h", has_target = false)] + public delegate void CallbackMarshal (Gtk.Object object, void* data, Gtk.Arg[] args); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate void CellLayoutDataFunc (Gtk.CellLayout cell_layout, Gtk.CellRenderer cell, Gtk.TreeModel tree_model, Gtk.TreeIter iter); + [CCode (cheader_filename = "gtk/gtk.h", has_target = false)] + public delegate void ClipboardClearFunc (Gtk.Clipboard clipboard, void* user_data_or_owner); + [CCode (cheader_filename = "gtk/gtk.h", has_target = false)] + public delegate void ClipboardGetFunc (Gtk.Clipboard clipboard, Gtk.SelectionData selection_data, uint info, void* user_data_or_owner); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate void ClipboardImageReceivedFunc (Gtk.Clipboard clipboard, Gdk.Pixbuf pixbuf); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate void ClipboardReceivedFunc (Gtk.Clipboard clipboard, Gtk.SelectionData selection_data); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate void ClipboardRichTextReceivedFunc (Gtk.Clipboard clipboard, Gdk.Atom format, [CCode (array_length_type = "gsize")] uint8[] text); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate void ClipboardTargetsReceivedFunc (Gtk.Clipboard clipboard, Gdk.Atom[] atoms); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate void ClipboardTextReceivedFunc (Gtk.Clipboard clipboard, string? text); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate void ClipboardURIReceivedFunc (Gtk.Clipboard clipboard, [CCode (array_length = false, array_null_terminated = true)] string[] uris); + [CCode (cheader_filename = "gtk/gtk.h", has_target = false)] + public delegate void ColorSelectionChangePaletteFunc (Gdk.Color colors, int n_colors); + [CCode (cheader_filename = "gtk/gtk.h", has_target = false)] + public delegate void ColorSelectionChangePaletteWithScreenFunc (Gdk.Screen screen, Gdk.Color colors, int n_colors); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate bool EntryCompletionMatchFunc (Gtk.EntryCompletion completion, string key, Gtk.TreeIter iter); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate bool FileFilterFunc (Gtk.FileFilterInfo filter_info); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate bool Function (); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate void IconViewForeachFunc (Gtk.IconView icon_view, Gtk.TreePath path); + [CCode (cheader_filename = "gtk/gtk.h", has_target = false)] + public delegate int KeySnoopFunc (Gtk.Widget grab_widget, Gdk.EventKey event, void* func_data); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate void LinkButtonUriFunc (Gtk.LinkButton button, string link_); + [CCode (cheader_filename = "gtk/gtk.h", has_target = false)] + public delegate void MenuDetachFunc (Gtk.Widget attach_widget, Gtk.Menu menu); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate void MenuPositionFunc (Gtk.Menu menu, out int x, out int y, out bool push_in); + [CCode (cheader_filename = "gtk/gtk.h", has_target = false)] + public delegate void ModuleDisplayInitFunc (Gdk.Display display); + [CCode (cheader_filename = "gtk/gtk.h", has_target = false)] + public delegate void ModuleInitFunc (int argc, string argv); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate unowned Gtk.Notebook NotebookWindowCreationFunc (Gtk.Notebook source, Gtk.Widget page, int x, int y); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate void PageSetupDoneFunc (Gtk.PageSetup page_setup); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate void PrintSettingsFunc (string key, string value); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate void RadioActionCallback (Gtk.Action action, Gtk.Action current); + [CCode (cheader_filename = "gtk/gtk.h", has_target = false)] + public delegate bool RcPropertyParser (GLib.ParamSpec pspec, GLib.StringBuilder rc_string, GLib.Value property_value); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate bool RecentFilterFunc (Gtk.RecentFilterInfo filter_info); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate int RecentSortFunc (Gtk.RecentInfo a, Gtk.RecentInfo b); + [CCode (cheader_filename = "gtk/gtk.h", instance_pos = 5.9)] + public delegate bool TextBufferDeserializeFunc (Gtk.TextBuffer register_buffer, Gtk.TextBuffer content_buffer, Gtk.TextIter iter, [CCode (array_length_type = "gsize")] uint8[] data, bool create_tags) throws GLib.Error; + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate uchar TextBufferSerializeFunc (Gtk.TextBuffer register_buffer, Gtk.TextBuffer content_buffer, Gtk.TextIter start, Gtk.TextIter end, size_t length); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate bool TextCharPredicate (unichar ch); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate void TextTagTableForeach (Gtk.TextTag tag); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate unowned string TranslateFunc (string path); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate void TreeCellDataFunc (Gtk.TreeViewColumn tree_column, Gtk.CellRenderer cell, Gtk.TreeModel tree_model, Gtk.TreeIter iter); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate void TreeDestroyCountFunc (Gtk.TreeView tree_view, Gtk.TreePath path, int children); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate int TreeIterCompareFunc (Gtk.TreeModel model, Gtk.TreeIter a, Gtk.TreeIter b); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate void TreeModelFilterModifyFunc (Gtk.TreeModel model, Gtk.TreeIter iter, GLib.Value value, int column); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate bool TreeModelFilterVisibleFunc (Gtk.TreeModel model, Gtk.TreeIter iter); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate bool TreeModelForeachFunc (Gtk.TreeModel model, Gtk.TreePath path, Gtk.TreeIter iter); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate void TreeSelectionForeachFunc (Gtk.TreeModel model, Gtk.TreePath path, Gtk.TreeIter iter); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate bool TreeSelectionFunc (Gtk.TreeSelection selection, Gtk.TreeModel model, Gtk.TreePath path, bool path_currently_selected); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate bool TreeViewColumnDropFunc (Gtk.TreeView tree_view, Gtk.TreeViewColumn column, Gtk.TreeViewColumn prev_column, Gtk.TreeViewColumn next_column); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate void TreeViewMappingFunc (Gtk.TreeView tree_view, Gtk.TreePath path); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate bool TreeViewRowSeparatorFunc (Gtk.TreeModel model, Gtk.TreeIter iter); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate bool TreeViewSearchEqualFunc (Gtk.TreeModel model, int column, string key, Gtk.TreeIter iter); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate void TreeViewSearchPositionFunc (Gtk.TreeView tree_view, Gtk.Widget search_dialog); + [CCode (cheader_filename = "gtk/gtk.h")] + public delegate void WindowKeysForeachFunc (Gtk.Window window, uint keyval, Gdk.ModifierType modifiers, bool is_mnemonic); + [CCode (cheader_filename = "gtk/gtk.h")] + public const int ARG_READWRITE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const int BINARY_AGE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const int BUTTONBOX_DEFAULT; + [CCode (cheader_filename = "gtk/gtk.h")] + public const int INPUT_ERROR; + [CCode (cheader_filename = "gtk/gtk.h")] + public const int INTERFACE_AGE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const int MAJOR_VERSION; + [CCode (cheader_filename = "gtk/gtk.h")] + public const int MAX_COMPOSE_LEN; + [CCode (cheader_filename = "gtk/gtk.h")] + public const int MICRO_VERSION; + [CCode (cheader_filename = "gtk/gtk.h")] + public const int MINOR_VERSION; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PAPER_NAME_A3; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PAPER_NAME_A4; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PAPER_NAME_A5; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PAPER_NAME_B5; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PAPER_NAME_EXECUTIVE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PAPER_NAME_LEGAL; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PAPER_NAME_LETTER; + [CCode (cheader_filename = "gtk/gtk.h")] + public const int PARAM_READABLE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const int PARAM_READWRITE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const int PARAM_WRITABLE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const int PATH_PRIO_MASK; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_COLLATE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_DEFAULT_SOURCE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_DITHER; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_DUPLEX; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_FINISHINGS; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_MEDIA_TYPE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_NUMBER_UP; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_NUMBER_UP_LAYOUT; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_N_COPIES; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_ORIENTATION; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_OUTPUT_BIN; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_OUTPUT_FILE_FORMAT; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_OUTPUT_URI; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_PAGE_RANGES; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_PAGE_SET; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_PAPER_FORMAT; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_PAPER_HEIGHT; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_PAPER_WIDTH; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_PRINTER; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_PRINTER_LPI; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_PRINT_PAGES; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_QUALITY; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_RESOLUTION; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_RESOLUTION_X; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_RESOLUTION_Y; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_REVERSE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_SCALE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_USE_COLOR; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_WIN32_DRIVER_EXTRA; + [CCode (cheader_filename = "gtk/gtk.h")] + public const string PRINT_SETTINGS_WIN32_DRIVER_VERSION; + [CCode (cheader_filename = "gtk/gtk.h")] + public const int PRIORITY_REDRAW; + [CCode (cheader_filename = "gtk/gtk.h")] + public const int PRIORITY_RESIZE; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.ABOUT")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_ABOUT; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.ADD")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_ADD; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.APPLY")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_APPLY; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.BOLD")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_BOLD; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.CANCEL")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_CANCEL; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.CAPS_LOCK_WARNING")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_CAPS_LOCK_WARNING; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.CDROM")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_CDROM; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.CLEAR")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_CLEAR; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.CLOSE")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_CLOSE; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.COLOR_PICKER")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_COLOR_PICKER; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.CONNECT")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_CONNECT; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.CONVERT")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_CONVERT; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.COPY")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_COPY; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.CUT")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_CUT; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.DELETE")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_DELETE; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.DIALOG_AUTHENTICATION")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_DIALOG_AUTHENTICATION; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.DIALOG_ERROR")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_DIALOG_ERROR; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.DIALOG_INFO")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_DIALOG_INFO; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.DIALOG_QUESTION")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_DIALOG_QUESTION; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.DIALOG_WARNING")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_DIALOG_WARNING; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.DIRECTORY")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_DIRECTORY; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.DISCARD")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_DISCARD; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.DISCONNECT")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_DISCONNECT; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.DND")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_DND; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.DND_MULTIPLE")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_DND_MULTIPLE; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.EDIT")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_EDIT; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.EXECUTE")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_EXECUTE; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.FILE")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_FILE; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.FIND")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_FIND; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.FIND_AND_REPLACE")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_FIND_AND_REPLACE; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.FLOPPY")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_FLOPPY; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.FULLSCREEN")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_FULLSCREEN; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.GOTO_BOTTOM")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_GOTO_BOTTOM; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.GOTO_FIRST")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_GOTO_FIRST; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.GOTO_LAST")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_GOTO_LAST; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.GOTO_TOP")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_GOTO_TOP; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.GO_BACK")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_GO_BACK; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.GO_DOWN")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_GO_DOWN; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.GO_FORWARD")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_GO_FORWARD; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.GO_UP")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_GO_UP; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.HARDDISK")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_HARDDISK; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.HELP")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_HELP; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.HOME")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_HOME; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.INDENT")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_INDENT; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.INDEX")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_INDEX; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.INFO")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_INFO; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.ITALIC")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_ITALIC; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.JUMP_TO")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_JUMP_TO; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.JUSTIFY_CENTER")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_JUSTIFY_CENTER; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.JUSTIFY_FILL")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_JUSTIFY_FILL; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.JUSTIFY_LEFT")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_JUSTIFY_LEFT; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.JUSTIFY_RIGHT")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_JUSTIFY_RIGHT; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.FULLSCREEN")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_LEAVE_FULLSCREEN; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.MEDIA_FORWARD")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_MEDIA_FORWARD; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.MEDIA_NEXT")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_MEDIA_NEXT; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.MEDIA_PAUSE")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_MEDIA_PAUSE; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.MEDIA_PLAY")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_MEDIA_PLAY; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.MEDIA_PREVIOUS")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_MEDIA_PREVIOUS; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.MEDIA_RECORD")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_MEDIA_RECORD; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.MEDIA_REWIND")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_MEDIA_REWIND; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.MEDIA_STOP")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_MEDIA_STOP; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.MISSING_IMAGE")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_MISSING_IMAGE; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.NETWORK")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_NETWORK; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.NEW")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_NEW; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.NO")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_NO; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.OK")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_OK; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.OPEN")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_OPEN; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.ORIENTATION_LANDSCAPE")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_ORIENTATION_LANDSCAPE; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.ORIENTATION_PORTRAIT")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_ORIENTATION_PORTRAIT; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.ORIENTATION_REVERSE_LANDSCAPE")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_ORIENTATION_REVERSE_LANDSCAPE; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.ORIENTATION_REVERSE_PORTRAIT")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_ORIENTATION_REVERSE_PORTRAIT; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.PAGE_SETUP")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_PAGE_SETUP; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.PASTE")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_PASTE; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.PREFERENCES")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_PREFERENCES; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.PRINT")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_PRINT; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.PRINT_ERROR")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_PRINT_ERROR; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.PRINT_PAUSED")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_PRINT_PAUSED; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.PRINT_PREVIEW")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_PRINT_PREVIEW; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.PRINT_REPORT")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_PRINT_REPORT; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.PRINT_WARNING")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_PRINT_WARNING; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.PROPERTIES")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_PROPERTIES; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.QUIT")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_QUIT; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.REDO")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_REDO; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.REFRESH")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_REFRESH; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.REMOVE")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_REMOVE; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.REVERT_TO_SAVED")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_REVERT_TO_SAVED; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.SAVE")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_SAVE; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.SAVE_AS")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_SAVE_AS; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.SELECT_ALL")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_SELECT_ALL; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.SELECT_COLOR")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_SELECT_COLOR; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.SELECT_FONT")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_SELECT_FONT; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.SORT_ASCENDING")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_SORT_ASCENDING; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.SORT_DESCENDING")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_SORT_DESCENDING; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.SPELL_CHECK")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_SPELL_CHECK; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.STOP")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_STOP; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.STRIKETHROUGH")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_STRIKETHROUGH; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.UNDELETE")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_UNDELETE; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.UNDERLINE")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_UNDERLINE; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.UNDO")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_UNDO; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.UNINDENT")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_UNINDENT; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.YES")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_YES; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.ZOOM_100")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_ZOOM_100; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.ZOOM_FIT")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_ZOOM_FIT; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.ZOOM_IN")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_ZOOM_IN; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.ZOOM_OUT")] + [CCode (cheader_filename = "gtk/gtk.h")] + public const string STOCK_ZOOM_OUT; + [CCode (cheader_filename = "gtk/gtk.h")] + public const int TEXT_VIEW_PRIORITY_VALIDATE; + [CCode (cheader_filename = "gtk/gtk.h")] + public const int TYPE_FUNDAMENTAL_LAST; + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool accel_groups_activate (GLib.Object object, uint accel_key, Gdk.ModifierType accel_mods); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned GLib.SList accel_groups_from_object (GLib.Object object); + [CCode (cheader_filename = "gtk/gtk.h")] + public static uint accelerator_get_default_mod_mask (); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned string accelerator_get_label (uint accelerator_key, Gdk.ModifierType accelerator_mods); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned string accelerator_name (uint accelerator_key, Gdk.ModifierType accelerator_mods); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void accelerator_parse (string accelerator, out uint accelerator_key, out Gdk.ModifierType accelerator_mods); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void accelerator_set_default_mod_mask (Gdk.ModifierType default_mod_mask); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool accelerator_valid (uint keyval, Gdk.ModifierType modifiers); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool alternative_dialog_button_order (Gdk.Screen screen); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool bindings_activate (Gtk.Object object, uint keyval, Gdk.ModifierType modifiers); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool bindings_activate_event (Gtk.Object object, Gdk.EventKey event); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned string check_version (uint required_major, uint required_minor, uint required_micro); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void disable_setlocale (); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned Gdk.DragContext drag_begin (Gtk.Widget widget, Gtk.TargetList targets, Gdk.DragAction actions, int button, Gdk.Event event); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool drag_check_threshold (Gtk.Widget widget, int start_x, int start_y, int current_x, int current_y); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_dest_add_image_targets (Gtk.Widget widget); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_dest_add_text_targets (Gtk.Widget widget); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_dest_add_uri_targets (Gtk.Widget widget); + [CCode (cheader_filename = "gtk/gtk.h")] + public static Gdk.Atom drag_dest_find_target (Gtk.Widget widget, Gdk.DragContext context, Gtk.TargetList target_list); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned Gtk.TargetList drag_dest_get_target_list (Gtk.Widget widget); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool drag_dest_get_track_motion (Gtk.Widget widget); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_dest_set (Gtk.Widget widget, Gtk.DestDefaults flags, Gtk.TargetEntry[] targets, Gdk.DragAction actions); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_dest_set_proxy (Gtk.Widget widget, Gdk.Window proxy_window, Gdk.DragProtocol protocol, bool use_coordinates); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_dest_set_target_list (Gtk.Widget widget, Gtk.TargetList target_list); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_dest_set_track_motion (Gtk.Widget widget, bool track_motion); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_dest_unset (Gtk.Widget widget); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_finish (Gdk.DragContext context, bool success, bool del, uint32 time_); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_get_data (Gtk.Widget widget, Gdk.DragContext context, Gdk.Atom target, uint32 time_); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned Gtk.Widget drag_get_source_widget (Gdk.DragContext context); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_highlight (Gtk.Widget widget); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_set_icon_default (Gdk.DragContext context); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_set_icon_name (Gdk.DragContext context, string icon_name, int hot_x, int hot_y); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_set_icon_pixbuf (Gdk.DragContext context, Gdk.Pixbuf pixbuf, int hot_x, int hot_y); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_set_icon_pixmap (Gdk.DragContext context, Gdk.Colormap colormap, Gdk.Pixmap pixmap, Gdk.Bitmap mask, int hot_x, int hot_y); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_set_icon_stock (Gdk.DragContext context, string stock_id, int hot_x, int hot_y); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_set_icon_widget (Gdk.DragContext context, Gtk.Widget widget, int hot_x, int hot_y); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_source_add_image_targets (Gtk.Widget widget); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_source_add_text_targets (Gtk.Widget widget); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_source_add_uri_targets (Gtk.Widget widget); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned Gtk.TargetList drag_source_get_target_list (Gtk.Widget widget); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_source_set (Gtk.Widget widget, Gdk.ModifierType start_button_mask, Gtk.TargetEntry[] targets, Gdk.DragAction actions); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_source_set_icon (Gtk.Widget widget, Gdk.Colormap colormap, Gdk.Pixmap pixmap, Gdk.Bitmap mask); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_source_set_icon_name (Gtk.Widget widget, string icon_name); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_source_set_icon_pixbuf (Gtk.Widget widget, Gdk.Pixbuf pixbuf); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_source_set_icon_stock (Gtk.Widget widget, string stock_id); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_source_set_target_list (Gtk.Widget widget, Gtk.TargetList target_list); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_source_unset (Gtk.Widget widget); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void drag_unhighlight (Gtk.Widget widget); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void draw_insertion_cursor (Gtk.Widget widget, Gdk.Drawable drawable, Gdk.Rectangle area, Gdk.Rectangle location, bool is_primary, Gtk.TextDirection direction, bool draw_arrow); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool events_pending (); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned Gdk.GC gc_get (int depth, Gdk.Colormap colormap, Gdk.GCValues values, Gdk.GCValuesMask values_mask); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void gc_release (Gdk.GC gc); + [CCode (cheader_filename = "gtk/gtk.h")] + public static Gdk.Event get_current_event (); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool get_current_event_state (out Gdk.ModifierType state); + [CCode (cheader_filename = "gtk/gtk.h")] + public static uint32 get_current_event_time (); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned Pango.Language get_default_language (); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned Gtk.Widget get_event_widget (Gdk.Event event); + [CCode (cheader_filename = "gtk/gtk.h")] + public static GLib.OptionGroup get_option_group (bool open_default_display); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void grab_add (Gtk.Widget widget); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned Gtk.Widget grab_get_current (); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void grab_remove (Gtk.Widget widget); + [CCode (cheader_filename = "gtk/gtk.h")] + public static Gtk.IconSize icon_size_from_name (string name); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned string icon_size_get_name (Gtk.IconSize size); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool icon_size_lookup (Gtk.IconSize size, out int width, out int height); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool icon_size_lookup_for_settings (Gtk.Settings settings, Gtk.IconSize size, out int width, out int height); + [CCode (cheader_filename = "gtk/gtk.h")] + public static Gtk.IconSize icon_size_register (string name, int width, int height); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void icon_size_register_alias (string alias, Gtk.IconSize target); + [CCode (cheader_filename = "gtk/gtk.h")] + public static GLib.Type identifier_get_type (); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void init ([CCode (array_length_pos = 0.9)] ref unowned string[] argv); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void init_add (Gtk.Function function); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool init_check ([CCode (array_length_pos = 0.9)] ref unowned string[] argv); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool init_with_args ([CCode (array_length_pos = 0.9)] ref unowned string[] argv, string parameter_string, [CCode (array_length = false)] GLib.OptionEntry[] entries, string? translation_domain) throws GLib.Error; + [CCode (cheader_filename = "gtk/gtk.h")] + public static uint key_snooper_install (Gtk.KeySnoopFunc snooper, void* func_data); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void key_snooper_remove (uint snooper_handler_id); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void main (); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void main_do_event (Gdk.Event event); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool main_iteration (); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool main_iteration_do (bool blocking); + [CCode (cheader_filename = "gtk/gtk.h")] + public static uint main_level (); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void main_quit (); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void paint_arrow (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle? area, Gtk.Widget? widget, string? detail, Gtk.ArrowType arrow_type, bool fill, int x, int y, int width, int height); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void paint_box (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle? area, Gtk.Widget? widget, string? detail, int x, int y, int width, int height); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void paint_box_gap (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle? area, Gtk.Widget? widget, string? detail, int x, int y, int width, int height, Gtk.PositionType gap_side, int gap_x, int gap_width); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void paint_check (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle? area, Gtk.Widget? widget, string? detail, int x, int y, int width, int height); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void paint_diamond (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle? area, Gtk.Widget? widget, string? detail, int x, int y, int width, int height); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void paint_expander (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gdk.Rectangle? area, Gtk.Widget? widget, string? detail, int x, int y, Gtk.ExpanderStyle expander_style); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void paint_extension (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle? area, Gtk.Widget? widget, string? detail, int x, int y, int width, int height, Gtk.PositionType gap_side); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void paint_flat_box (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle? area, Gtk.Widget? widget, string? detail, int x, int y, int width, int height); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void paint_focus (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gdk.Rectangle? area, Gtk.Widget? widget, string? detail, int x, int y, int width, int height); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void paint_handle (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle? area, Gtk.Widget? widget, string? detail, int x, int y, int width, int height, Gtk.Orientation orientation); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void paint_hline (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gdk.Rectangle? area, Gtk.Widget? widget, string? detail, int x1, int x2, int y); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void paint_layout (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, bool use_text, Gdk.Rectangle? area, Gtk.Widget? widget, string? detail, int x, int y, Pango.Layout layout); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void paint_option (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle? area, Gtk.Widget? widget, string? detail, int x, int y, int width, int height); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void paint_polygon (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle? area, Gtk.Widget? widget, string? detail, Gdk.Point[] points, bool fill); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void paint_resize_grip (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gdk.Rectangle? area, Gtk.Widget? widget, string? detail, Gdk.WindowEdge edge, int x, int y, int width, int height); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void paint_shadow (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle? area, Gtk.Widget? widget, string? detail, int x, int y, int width, int height); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void paint_shadow_gap (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle? area, Gtk.Widget? widget, string? detail, int x, int y, int width, int height, Gtk.PositionType gap_side, int gap_x, int gap_width); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void paint_slider (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle? area, Gtk.Widget? widget, string? detail, int x, int y, int width, int height, Gtk.Orientation orientation); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void paint_spinner (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, uint step, int x, int y, int width, int height); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void paint_tab (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle? area, Gtk.Widget? widget, string? detail, int x, int y, int width, int height); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void paint_vline (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gdk.Rectangle? area, Gtk.Widget? widget, string? detail, int y1_, int y2_, int x); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool parse_args (int argc, string[] argv); + [CCode (cheader_filename = "gtk/gtk.h")] + public static GLib.Quark print_error_quark (); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned Gtk.PageSetup print_run_page_setup_dialog (Gtk.Window parent, Gtk.PageSetup page_setup, Gtk.PrintSettings settings); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void print_run_page_setup_dialog_async (Gtk.Window parent, Gtk.PageSetup page_setup, Gtk.PrintSettings settings, Gtk.PageSetupDoneFunc done_cb, void* data); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void propagate_event (Gtk.Widget widget, Gdk.Event event); + [CCode (cheader_filename = "gtk/gtk.h")] + public static uint quit_add (uint main_level, Gtk.Function function); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void quit_add_destroy (uint main_level, Gtk.Object object); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void quit_remove (uint quit_handler_id); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void quit_remove_by_data (void* data); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void rc_add_default_file (string filename); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned string rc_find_module_in_path (string module_file); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned string rc_find_pixmap_in_path (Gtk.Settings settings, GLib.Scanner scanner, string pixmap_file); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned string rc_get_default_files (); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned string rc_get_im_module_file (); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned string rc_get_im_module_path (); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned string rc_get_module_dir (); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned Gtk.Style rc_get_style (Gtk.Widget widget); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned Gtk.Style? rc_get_style_by_paths (Gtk.Settings settings, string? widget_path, string? class_path, GLib.Type type); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned string rc_get_theme_dir (); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void rc_parse (string filename); + [CCode (cheader_filename = "gtk/gtk.h")] + public static uint rc_parse_color (GLib.Scanner scanner, Gdk.Color color); + [CCode (cheader_filename = "gtk/gtk.h")] + public static uint rc_parse_color_full (GLib.Scanner scanner, Gtk.RcStyle style, Gdk.Color color); + [CCode (cheader_filename = "gtk/gtk.h")] + public static uint rc_parse_priority (GLib.Scanner scanner, Gtk.PathPriorityType priority); + [CCode (cheader_filename = "gtk/gtk.h")] + public static uint rc_parse_state (GLib.Scanner scanner, Gtk.StateType state); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void rc_parse_string (string rc_string); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool rc_reparse_all (); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool rc_reparse_all_for_settings (Gtk.Settings settings, bool force_load); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void rc_reset_styles (Gtk.Settings settings); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned GLib.Scanner rc_scanner_new (); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void rc_set_default_files (string filenames); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void rgb_to_hsv (double r, double g, double b, double h, double s, double v); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void selection_add_target (Gtk.Widget widget, Gdk.Atom selection, Gdk.Atom target, uint info); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void selection_add_targets (Gtk.Widget widget, Gdk.Atom selection, Gtk.TargetEntry[] targets, uint ntargets); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool selection_clear (Gtk.Widget widget, Gdk.EventSelection event); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void selection_clear_targets (Gtk.Widget widget, Gdk.Atom selection); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool selection_convert (Gtk.Widget widget, Gdk.Atom selection, Gdk.Atom target, uint32 time_); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool selection_owner_set (Gtk.Widget widget, Gdk.Atom selection, uint32 time_); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool selection_owner_set_for_display (Gdk.Display display, Gtk.Widget widget, Gdk.Atom selection, uint32 time_); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void selection_remove_all (Gtk.Widget widget); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned string set_locale (); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void show_about_dialog (Gtk.Window? parent, ...); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool show_uri (Gdk.Screen? screen, string uri, uint32 timestamp) throws GLib.Error; + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.add")] + [CCode (cheader_filename = "gtk/gtk.h")] + public static void stock_add (Gtk.StockItem[] items); + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.add_static")] + [CCode (cheader_filename = "gtk/gtk.h")] + public static void stock_add_static (Gtk.StockItem[] items); + [Deprecated (since = "vala-0.12", replacement = "Gtk.Stock.list_ids")] + [CCode (cheader_filename = "gtk/gtk.h")] + public static GLib.SList stock_list_ids (); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void stock_set_translate_func (string domain, owned Gtk.TranslateFunc func); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void target_table_free (Gtk.TargetEntry[] targets); + [CCode (cheader_filename = "gtk/gtk.h")] + public static Gtk.TargetEntry[] target_table_new_from_list (Gtk.TargetList list); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool targets_include_image (Gdk.Atom[] targets, bool writable); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool targets_include_rich_text (Gdk.Atom[] targets, Gtk.TextBuffer buffer); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool targets_include_text (Gdk.Atom[] targets); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool targets_include_uri (Gdk.Atom[] targets); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned Gtk.Widget test_create_simple_window (string window_title, string dialog_text); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned Gtk.Widget test_create_widget (GLib.Type widget_type, ...); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned Gtk.Widget test_display_button_window (string window_title, string dialog_text); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned Gtk.Widget test_find_label (Gtk.Widget widget, string label_pattern); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned Gtk.Widget test_find_sibling (Gtk.Widget base_widget, GLib.Type widget_type); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned Gtk.Widget test_find_widget (Gtk.Widget widget, string label_pattern, GLib.Type widget_type); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void test_init (int argcp, out unowned string argvp); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned GLib.Type[] test_list_all_types (uint n_types); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void test_register_all_types (); + [CCode (cheader_filename = "gtk/gtk.h")] + public static double test_slider_get_value (Gtk.Widget widget); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void test_slider_set_perc (Gtk.Widget widget, double percentage); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool test_spin_button_click (Gtk.SpinButton spinner, uint button, bool upwards); + [CCode (cheader_filename = "gtk/gtk.h")] + public static unowned string test_text_get (Gtk.Widget widget); + [CCode (cheader_filename = "gtk/gtk.h")] + public static void test_text_set (Gtk.Widget widget, string str); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool test_widget_click (Gtk.Widget widget, uint button, Gdk.ModifierType modifiers); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool test_widget_send_key (Gtk.Widget widget, uint keyval, Gdk.ModifierType modifiers); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool tree_get_row_drag_data (Gtk.SelectionData selection_data, out unowned Gtk.TreeModel tree_model, out unowned Gtk.TreePath path); + [CCode (cheader_filename = "gtk/gtk.h")] + public static bool tree_set_row_drag_data (Gtk.SelectionData selection_data, Gtk.TreeModel tree_model, Gtk.TreePath path); +} diff --git a/vapi/gtk+-2.0.vapi.diff b/vapi/gtk+-2.0.vapi.diff new file mode 100644 index 0000000..b17f831 --- /dev/null +++ b/vapi/gtk+-2.0.vapi.diff @@ -0,0 +1,4 @@ +4182c4182 +< public weak GLib.List children; +--- +> public weak GLib.List children; diff --git a/vapi/keysym.vapi b/vapi/keysym.vapi new file mode 100644 index 0000000..edf2ad5 --- /dev/null +++ b/vapi/keysym.vapi @@ -0,0 +1,56 @@ +/* keysym.vapi generated by valac 0.13.1, do not modify. */ + +[CCode (cprefix = "NeoLayoutViewer", lower_case_cprefix = "neo_layout_viewer_")] +namespace NeoLayoutViewer { + [CCode (cheader_filename = "neo2.h")] + public class KeyEventBox : Gtk.EventBox { + public KeyEventBox (NeoLayoutViewer.NeoWindow winMain, int width, int height, ref uint[] keysym); + public KeyEventBox.freeArea (NeoLayoutViewer.NeoWindow winMain, int width, int height); + public KeyEventBox.modifier (NeoLayoutViewer.NeoWindow winMain, int width, int height, int modifier_index); + public KeyEventBox.modifier2 (NeoLayoutViewer.NeoWindow winMain, int width, int height, int modifier_index); + public override void size_request (out Gtk.Requisition requisition); + } + [CCode (cheader_filename = "neo2.h")] + public class KeyOverlay : Gtk.VBox { + public Gee.HashMap keyBoxes; + public Gee.HashMap keysyms; + public KeyOverlay (NeoLayoutViewer.NeoWindow winMain); + public void generateKeyevents (); + public Gee.HashMap generateKeysyms (); + } + [CCode (cheader_filename = "neo2.h")] + public class KeybindingManager : GLib.Object { + [CCode (cheader_filename = "neo2.h")] + public delegate void KeybindingHandlerFunc (Gdk.Event event); + public KeybindingManager (NeoLayoutViewer.NeoWindow neo_win); + public void bind (string accelerator, NeoLayoutViewer.KeybindingManager.KeybindingHandlerFunc handler); + public void bind2 (int keycode, string accelerator, int ebene, NeoLayoutViewer.KeybindingManager.KeybindingHandlerFunc handler); + public Gdk.FilterReturn event_filter (Gdk.XEvent gdk_xevent, Gdk.Event gdk_event); + public void unbind (string accelerator); + public void unbind2 (int keycode); + } + [CCode (cheader_filename = "neo2.h")] + public class NeoWindow : Gtk.Window { + public int[] MODIFIER_MASK; + public int[] NEO_MODIFIER_MASK; + public int[] active_modifier; + public Gee.HashMap config; + public int ebene; + public int numblock_width; + public Gtk.Label status; + public NeoWindow (string sebene, Gee.HashMap config); + public void external_key_press (int iet1, int modifier_mask); + public void external_key_release (int iet1, int modifier_mask); + public Gdk.Pixbuf getIcon (); + public void get_size2 (out int width, out int height); + public override void hide_all (); + public void load_image_buffer (); + public static int main (string[] args); + public void numkeypad_move (int pos); + public Gdk.Pixbuf open_image (int ebene); + public Gdk.Pixbuf open_image_str (string bildpfad); + public void redraw (); + public override void show_all (); + public bool toggle (); + } +}