~ubuntu-branches/ubuntu/quantal/vala/quantal

public virtual void foreach_alloc (Gtk.CellAreaContext context, Gtk.Widget widget, Gdk.Rectangle cell_area, Gdk.Rectangle background_area, Gtk.CellAllocCallback callback, void* callback_data);

846

public void get_cell_allocation (Gtk.CellAreaContext context, Gtk.Widget widget, Gtk.CellRenderer renderer, Gdk.Rectangle cell_area, Gdk.Rectangle allocation);

847

public unowned Gtk.CellRenderer get_cell_at_position (Gtk.CellAreaContext context, Gtk.Widget widget, Gdk.Rectangle cell_area, int x, int y, Gdk.Rectangle alloc_area);

848

[NoWrapper]

849

public virtual void get_cell_property (Gtk.CellRenderer renderer, uint property_id, GLib.Value value, GLib.ParamSpec pspec);

850

public unowned string get_current_path_string ();

851

public unowned Gtk.CellEditable get_edit_widget ();

852

public unowned Gtk.CellRenderer get_edited_cell ();

853

public unowned Gtk.CellRenderer get_focus_cell ();

854

public unowned Gtk.CellRenderer get_focus_from_sibling (Gtk.CellRenderer renderer);

855

public unowned GLib.List get_focus_siblings (Gtk.CellRenderer renderer);

856

public virtual void get_preferred_height (Gtk.CellAreaContext context, Gtk.Widget widget, int minimum_height, int natural_height);

857

public virtual void get_preferred_height_for_width (Gtk.CellAreaContext context, Gtk.Widget widget, int width, int minimum_height, int natural_height);

858

public virtual void get_preferred_width (Gtk.CellAreaContext context, Gtk.Widget widget, int minimum_width, int natural_width);

859

public virtual void get_preferred_width_for_height (Gtk.CellAreaContext context, Gtk.Widget widget, int height, int minimum_width, int natural_width);

860

public virtual Gtk.SizeRequestMode get_request_mode ();

861

public unowned string get_style_detail ();

862

public bool has_renderer (Gtk.CellRenderer renderer);

863

public void inner_cell_area (Gtk.Widget widget, Gdk.Rectangle cell_area, Gdk.Rectangle inner_area);

864

[CCode (cname = "gtk_cell_area_class_install_cell_property")]

865

public class void install_cell_property (uint property_id, GLib.ParamSpec pspec);

866

public virtual bool is_activatable ();

867

public bool is_focus_sibling (Gtk.CellRenderer renderer, Gtk.CellRenderer sibling);

868

[CCode (cname = "gtk_cell_area_class_list_cell_properties")]

869

public class unowned GLib.ParamSpec list_cell_properties (uint n_properties);

870

public virtual void remove (Gtk.CellRenderer renderer);

871

public void remove_focus_sibling (Gtk.CellRenderer renderer, Gtk.CellRenderer sibling);

872

public virtual void render (Gtk.CellAreaContext context, Gtk.Widget widget, Cairo.Context cr, Gdk.Rectangle background_area, Gdk.Rectangle cell_area, Gtk.CellRendererState flags, bool paint_focus);

873

public void request_renderer (Gtk.CellRenderer renderer, Gtk.Orientation orientation, Gtk.Widget widget, int for_size, int minimum_size, int natural_size);

874

[NoWrapper]

875

public virtual void set_cell_property (Gtk.CellRenderer renderer, uint property_id, GLib.Value value, GLib.ParamSpec pspec);

876

public void set_focus_cell (Gtk.CellRenderer renderer);

877

public void set_style_detail (string detail);

878

public void stop_editing (bool canceled);

879

public Gtk.CellEditable edit_widget { get; }

880

public Gtk.CellRenderer edited_cell { get; }

881

public Gtk.CellRenderer focus_cell { get; set; }

882

public virtual signal void add_editable (Gtk.CellRenderer p0, Gtk.CellEditable p1, Gdk.Rectangle p2, string p3);

883

[HasEmitter]

884

public virtual signal void apply_attributes (Gtk.TreeModel tree_model, Gtk.TreeIter iter, bool is_expander, bool is_expanded);

885

public virtual signal void focus_changed (Gtk.CellRenderer p0, string p1);

886

public virtual signal void remove_editable (Gtk.CellRenderer p0, Gtk.CellEditable p1);

887

}

888

[CCode (cheader_filename = "gtk/gtk.h")]

889

public class CellAreaBox : Gtk.CellArea, Gtk.CellLayout, Gtk.Buildable, Gtk.Orientable {

890

[CCode (type = "GtkCellArea*", has_construct_function = false)]

891

public CellAreaBox ();

892

public int get_spacing ();

893

public void set_spacing (int spacing);

894

public int spacing { get; set; }

895

}

896

[CCode (cheader_filename = "gtk/gtk.h")]

897

public class CellAreaContext : GLib.Object {

898

[CCode (has_construct_function = false)]

899

protected CellAreaContext ();

900

public virtual void allocate (int width, int height);

901

public void get_allocation (int width, int height);

902

public unowned Gtk.CellArea get_area ();

903

public void get_preferred_height (int minimum_height, int natural_height);

904

public virtual void get_preferred_height_for_width (int width, int minimum_height, int natural_height);

905

public void get_preferred_width (int minimum_width, int natural_width);

906

public virtual void get_preferred_width_for_height (int height, int minimum_width, int natural_width);

907

public void push_preferred_height (int minimum_height, int natural_height);

908

public void push_preferred_width (int minimum_width, int natural_width);

909

public virtual void reset ();

910

public Gtk.CellArea area { get; construct; }

911

[NoAccessorMethod]

912

public int minimum_height { get; }

913

[NoAccessorMethod]

914

public int minimum_width { get; }

915

[NoAccessorMethod]

916

public int natural_height { get; }

917

[NoAccessorMethod]

918

public int natural_width { get; }

919

}

920

[CCode (cheader_filename = "gtk/gtk.h")]

780

921

public abstract class CellRenderer : GLib.InitiallyUnowned {

781

922

[CCode (has_construct_function = false)]

782

923

protected CellRenderer ();

783

924

public virtual bool activate (Gdk.Event event, Gtk.Widget widget, string path, Gdk.Rectangle background_area, Gdk.Rectangle cell_area, Gtk.CellRendererState flags);

925

public virtual void get_aligned_area (Gtk.Widget widget, Gtk.CellRendererState flags, Gdk.Rectangle cell_area, Gdk.Rectangle aligned_area);

784

926

public void get_alignment (float xalign, float yalign);

785

927

public void get_fixed_size (out int width, out int height);

786

928

public void get_padding (int xpad, int ypad);

787

public virtual void get_preferred_height (Gtk.Widget widget, int minimum_size, int natural_size);

788

public virtual void get_preferred_height_for_width (Gtk.Widget widget, int width, int minimum_height, int natural_height);

789

public void get_preferred_size (Gtk.Widget widget, Gtk.Requisition minimum_size, Gtk.Requisition natural_size);

790

public virtual void get_preferred_width (Gtk.Widget widget, int minimum_size, int natural_size);

791

public virtual void get_preferred_width_for_height (Gtk.Widget widget, int height, int minimum_width, int natural_width);

929

public virtual void get_preferred_height (Gtk.Widget widget, out int minimum_size, out int natural_size);

930

public virtual void get_preferred_height_for_width (Gtk.Widget widget, int width, out int minimum_height, out int natural_height);

931

public void get_preferred_size (Gtk.Widget widget, out Gtk.Requisition minimum_size, out Gtk.Requisition natural_size);

932

public virtual void get_preferred_width (Gtk.Widget widget, out int minimum_size, out int natural_size);

933

public virtual void get_preferred_width_for_height (Gtk.Widget widget, int height, out int minimum_width, out int natural_width);

792

934

public virtual Gtk.SizeRequestMode get_request_mode ();

793

935

public bool get_sensitive ();

794

936

[NoWrapper]

795

937

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);

796

938

public bool get_visible ();

939

public bool is_activatable ();

797

940

public abstract void render (Cairo.Context cr, Gtk.Widget widget, Gdk.Rectangle background_area, Gdk.Rectangle cell_area, Gtk.CellRendererState flags);

798

941

public void set_alignment (float xalign, float yalign);

799

942

public void set_fixed_size (int width, int height);

1046

1189

public virtual signal void toggled (string path);

1047

1190

}

1048

1191

[CCode (cheader_filename = "gtk/gtk.h")]

1049

public class CellView : Gtk.Widget, Atk.Implementor, Gtk.Buildable, Gtk.CellLayout {

1192

public class CellView : Gtk.Widget, Atk.Implementor, Gtk.Buildable, Gtk.CellLayout, Gtk.Orientable {

1050

1193

[CCode (type = "GtkWidget*", has_construct_function = false)]

1051

1194

public CellView ();

1052

public void get_desired_height_for_width_of_row (Gtk.TreePath path, int avail_size, int minimum_size, int natural_size);

1053

public void get_desired_width_of_row (Gtk.TreePath path, int minimum_size, int natural_size);

1054

1195

public unowned Gtk.TreePath get_displayed_row ();

1196

public bool get_draw_sensitive ();

1197

public bool get_fit_model ();

1055

1198

public unowned Gtk.TreeModel get_model ();

1056

1199

public void set_background_color (Gdk.Color color);

1057

1200

public void set_background_rgba (Gdk.RGBA rgba);

1058

1201

public void set_displayed_row (Gtk.TreePath path);

1202

public void set_draw_sensitive (bool draw_sensitive);

1203

public void set_fit_model (bool fit_model);

1059

1204

public void set_model (Gtk.TreeModel? model);

1060

1205

[CCode (type = "GtkWidget*", has_construct_function = false)]

1206

public CellView.with_context (Gtk.CellArea area, Gtk.CellAreaContext context);

1207

[CCode (type = "GtkWidget*", has_construct_function = false)]

1061

1208

public CellView.with_markup (string markup);

1062

1209

[CCode (type = "GtkWidget*", has_construct_function = false)]

1063

1210

public CellView.with_pixbuf (Gdk.Pixbuf pixbuf);

1071

1218

public Gdk.RGBA background_rgba { get; set; }

1072

1219

[NoAccessorMethod]

1073

1220

public bool background_set { get; set; }

1221

[NoAccessorMethod]

1222

public Gtk.CellArea cell_area { owned get; construct; }

1223

[NoAccessorMethod]

1224

public Gtk.CellAreaContext cell_area_context { owned get; construct; }

1225

public bool draw_sensitive { get; set; }

1226

public bool fit_model { get; set; }

1074

1227

public Gtk.TreeModel model { get; set; }

1075

1228

}

1076

1229

[CCode (cheader_filename = "gtk/gtk.h")]

1214

1367

[CCode (type = "GtkWidget*", has_construct_function = false)]

1215

1368

public ComboBox ();

1216

1369

public int get_active ();

1370

public unowned string get_active_id ();

1217

1371

public bool get_active_iter (out Gtk.TreeIter iter);

1218

1372

public bool get_add_tearoffs ();

1219

1373

public Gtk.SensitivityType get_button_sensitivity ();

1221

1375

public int get_entry_text_column ();

1222

1376

public bool get_focus_on_click ();

1223

1377

public bool get_has_entry ();

1378

public int get_id_column ();

1224

1379

public unowned Gtk.TreeModel get_model ();

1225

1380

public unowned Atk.Object get_popup_accessible ();

1226

1381

public bool get_popup_fixed_width ();

1230

1385

public int get_wrap_width ();

1231

1386

public void popup_for_device (Gdk.Device device);

1232

1387

public void set_active (int index_);

1388

public void set_active_id (string active_id);

1233

1389

public void set_active_iter (Gtk.TreeIter iter);

1234

1390

public void set_add_tearoffs (bool add_tearoffs);

1235

1391

public void set_button_sensitivity (Gtk.SensitivityType sensitivity);

1236

1392

public void set_column_span_column (int column_span);

1237

1393

public void set_entry_text_column (int text_column);

1238

1394

public void set_focus_on_click (bool focus_on_click);

1395

public void set_id_column (int id_column);

1239

1396

public void set_model (Gtk.TreeModel? model);

1240

1397

public void set_popup_fixed_width (bool fixed);

1241

1398

public void set_row_separator_func (owned Gtk.TreeViewRowSeparatorFunc func);

1243

1400

public void set_title (string title);

1244

1401

public void set_wrap_width (int width);

1245

1402

[CCode (type = "GtkWidget*", has_construct_function = false)]

1403

public ComboBox.with_area (Gtk.CellArea area);

1404

[CCode (type = "GtkWidget*", has_construct_function = false)]

1405

public ComboBox.with_area_and_entry (Gtk.CellArea area);

1406

[CCode (type = "GtkWidget*", has_construct_function = false)]

1246

1407

public ComboBox.with_entry ();

1247

1408

[CCode (type = "GtkWidget*", has_construct_function = false)]

1248

1409

public ComboBox.with_model (Gtk.TreeModel model);

1249

1410

[CCode (type = "GtkWidget*", has_construct_function = false)]

1250

1411

public ComboBox.with_model_and_entry (Gtk.TreeModel model);

1251

1412

public int active { get; set; }

1413

public string active_id { get; set; }

1252

1414

public bool add_tearoffs { get; set; }

1253

1415

public Gtk.SensitivityType button_sensitivity { get; set; }

1416

[NoAccessorMethod]

1417

public Gtk.CellArea cell_area { owned get; construct; }

1254

1418

public int column_span_column { get; set; }

1255

1419

public int entry_text_column { get; set; }

1256

1420

public bool focus_on_click { get; set; }

1257

1421

public bool has_entry { get; construct; }

1258

1422

[NoAccessorMethod]

1259

1423

public bool has_frame { get; set; }

1424

public int id_column { get; set; }

1260

1425

public Gtk.TreeModel model { get; set; }

1261

1426

public bool popup_fixed_width { get; set; }

1262

1427

[NoAccessorMethod]

1276

1441

public class ComboBoxText : Gtk.ComboBox, Atk.Implementor, Gtk.Buildable, Gtk.CellLayout, Gtk.CellEditable {

1277

1442

[CCode (type = "GtkWidget*", has_construct_function = false)]

1278

1443

public ComboBoxText ();

1444

public void append (string id, string text);

1279

1445

public void append_text (string text);

1280

1446

public unowned string get_active_text ();

1447

public void insert (int position, string id, string text);

1281

1448

public void insert_text (int position, string text);

1449

public void prepend (string id, string text);

1282

1450

public void prepend_text (string text);

1283

1451

public void remove (int position);

1284

1452

public void remove_all ();

1313

1481

public unowned Gtk.Widget get_focus_child ();

1314

1482

public unowned Gtk.Adjustment get_focus_hadjustment ();

1315

1483

public unowned Gtk.Adjustment get_focus_vadjustment ();

1484

public virtual unowned Gtk.WidgetPath get_path_for_child (Gtk.Widget child);

1316

1485

public Gtk.ResizeMode get_resize_mode ();

1317

1486

[CCode (cname = "gtk_container_class_handle_border_width")]

1318

1487

public class void handle_border_width ();

1343

1512

public virtual signal void set_focus_child (Gtk.Widget? widget);

1344

1513

}

1345

1514

[CCode (cheader_filename = "gtk/gtk.h")]

1515

public class CssProvider : GLib.Object, Gtk.StyleProvider {

1516

[CCode (has_construct_function = false)]

1517

public CssProvider ();

1518

public static GLib.Quark error_quark ();

1519

public static unowned Gtk.CssProvider get_default ();

1520

public static unowned Gtk.CssProvider get_named (string name, string variant);

1521

public bool load_from_data (string data, ssize_t length) throws GLib.Error;

1522

public bool load_from_file (GLib.File file) throws GLib.Error;

1523

public bool load_from_path (string path) throws GLib.Error;

1524

}

1525

[CCode (cheader_filename = "gtk/gtk.h")]

1346

1526

public class Dialog : Gtk.Window, Atk.Implementor, Gtk.Buildable {

1347

1527

[CCode (type = "GtkWidget*", has_construct_function = false)]

1348

1528

public Dialog ();

1367

1547

}

1368

1548

[CCode (cheader_filename = "gtk/gtk.h")]

1369

1549

public class DrawingArea : Gtk.Widget, Atk.Implementor, Gtk.Buildable {

1550

public void* dummy;

1370

1551

[CCode (type = "GtkWidget*", has_construct_function = false)]

1371

1552

public DrawingArea ();

1372

1553

}

1569

1750

public void set_popup_set_width (bool popup_set_width);

1570

1751

public void set_popup_single_match (bool popup_single_match);

1571

1752

public void set_text_column (int column);

1753

[CCode (has_construct_function = false)]

1754

public EntryCompletion.with_area (Gtk.CellArea area);

1755

[NoAccessorMethod]

1756

public Gtk.CellArea cell_area { owned get; construct; }

1572

1757

public bool inline_completion { get; set; }

1573

1758

public bool inline_selection { get; set; }

1574

1759

public int minimum_key_length { get; set; }

1766

1951

public float label_yalign { get; set; }

1767

1952

public Gtk.ShadowType shadow_type { get; set; }

1768

1953

}

1954

[Compact]

1955

[CCode (ref_function = "gtk_gradient_ref", unref_function = "gtk_gradient_unref", type_id = "GTK_TYPE_GRADIENT", cheader_filename = "gtk/gtk.h")]

1956

public class Gradient {

1957

public void add_color_stop (double offset, Gtk.SymbolicColor color);

1958

[CCode (has_construct_function = false)]

1959

public Gradient.linear (double x0, double y0, double x1, double y1);

1960

[CCode (has_construct_function = false)]

1961

public Gradient.radial (double x0, double y0, double radius0, double x1, double y1, double radius1);

1962

public bool resolve (Gtk.StyleProperties props, out unowned Cairo.Pattern resolved_gradient);

1963

}

1769

1964

[CCode (cheader_filename = "gtk/gtk.h")]

1770

1965

public class Grid : Gtk.Container, Atk.Implementor, Gtk.Buildable, Gtk.Orientable {

1771

1966

[CCode (type = "GtkWidget*", has_construct_function = false)]

1801

1996

public HPaned ();

1802

1997

}

1803

1998

[CCode (cheader_filename = "gtk/gtk.h")]

1804

public class HRuler : Gtk.Ruler, Atk.Implementor, Gtk.Buildable, Gtk.Orientable {

1805

[CCode (type = "GtkWidget*", has_construct_function = false)]

1806

public HRuler ();

1807

}

1808

[CCode (cheader_filename = "gtk/gtk.h")]

1809

1999

public class HSV : Gtk.Widget, Atk.Implementor, Gtk.Buildable {

1810

2000

[CCode (type = "GtkWidget*", has_construct_function = false)]

1811

2001

public HSV ();

1914

2104

public unowned string get_filename ();

1915

2105

public Gdk.Pixbuf load_icon () throws GLib.Error;

1916

2106

public unowned Gdk.Pixbuf load_symbolic (Gdk.RGBA fg, Gdk.RGBA success_color, Gdk.RGBA warning_color, Gdk.RGBA error_color, bool was_symbolic) throws GLib.Error;

1917

public unowned Gdk.Pixbuf load_symbolic_for_style (Gtk.Style style, Gtk.StateType state, bool was_symbolic) throws GLib.Error;

2107

public unowned Gdk.Pixbuf load_symbolic_for_context (Gtk.StyleContext context, bool was_symbolic) throws GLib.Error;

1918

2108

public void set_raw_coordinates (bool raw_coordinates);

1919

2109

}

1920

2110

[Compact]

1928

2118

public IconSet.from_pixbuf (Gdk.Pixbuf pixbuf);

1929

2119

public void get_sizes (Gtk.IconSize[] sizes);

1930

2120

public unowned Gdk.Pixbuf render_icon (Gtk.Style style, Gtk.TextDirection direction, Gtk.StateType state, Gtk.IconSize size, Gtk.Widget widget, string detail);

2121

public unowned Gdk.Pixbuf render_icon_pixbuf (Gtk.StyleContext context, Gtk.IconSize size);

1931

2122

}

1932

2123

[Compact]

1933

2124

[CCode (copy_function = "gtk_icon_source_copy", type_id = "GTK_TYPE_ICON_SOURCE", cheader_filename = "gtk/gtk.h")]

2040

2231

public void unset_model_drag_dest ();

2041

2232

public void unset_model_drag_source ();

2042

2233

[CCode (type = "GtkWidget*", has_construct_function = false)]

2234

public IconView.with_area (Gtk.CellArea area);

2235

[CCode (type = "GtkWidget*", has_construct_function = false)]

2043

2236

public IconView.with_model (Gtk.TreeModel model);

2237

[NoAccessorMethod]

2238

public Gtk.CellArea cell_area { owned get; construct; }

2044

2239

public int column_spacing { get; set; }

2045

2240

public int columns { get; set; }

2046

2241

public Gtk.Orientation item_orientation { get; set; }

2292

2487

[CCode (cheader_filename = "gtk/gtk.h")]

2293

2488

public class Layout : Gtk.Container, Atk.Implementor, Gtk.Buildable, Gtk.Scrollable {

2294

2489

[CCode (type = "GtkWidget*", has_construct_function = false)]

2295

public Layout (Gtk.Adjustment hadjustment, Gtk.Adjustment vadjustment);

2490

public Layout (Gtk.Adjustment? hadjustment = null, Gtk.Adjustment? vadjustment = null);

2296

2491

public unowned Gdk.Window get_bin_window ();

2297

2492

public unowned Gtk.Adjustment get_hadjustment ();

2298

2493

public void get_size (out uint width, out uint height);

2407

2602

public MenuItem ();

2408

2603

public unowned string get_accel_path ();

2409

2604

public virtual unowned string get_label ();

2605

public bool get_reserve_indicator ();

2410

2606

public bool get_right_justified ();

2411

2607

public unowned Gtk.Widget get_submenu ();

2412

2608

public bool get_use_underline ();

2413

2609

public void set_accel_path (string accel_path);

2414

2610

public virtual void set_label (string label);

2611

public void set_reserve_indicator (bool reserve);

2415

2612

public void set_right_justified (bool right_justified);

2416

2613

public void set_submenu (Gtk.Widget submenu);

2417

2614

public void set_use_underline (bool setting);

2441

2638

public void activate_item (Gtk.Widget menu_item, bool force_deactivate);

2442

2639

public void append ([CCode (type = "GtkWidget*")] Gtk.MenuItem child);

2443

2640

public void deselect ();

2641

public unowned Gtk.Widget get_parent_shell ();

2444

2642

[NoWrapper]

2445

2643

public virtual int get_popup_delay ();

2644

public unowned Gtk.Widget get_selected_item ();

2446

2645

public bool get_take_focus ();

2447

2646

public virtual void insert (Gtk.Widget child, int position);

2448

2647

public void prepend (Gtk.Widget child);

2600

2799

public virtual signal void switch_page (Gtk.Widget page, uint page_num);

2601

2800

}

2602

2801

[CCode (cheader_filename = "gtk/gtk.h")]

2802

public class NumerableIcon : GLib.EmblemedIcon, GLib.Icon {

2803

[CCode (type = "GIcon*", has_construct_function = false)]

2804

public NumerableIcon (GLib.Icon base_icon);

2805

public unowned GLib.Icon get_background_gicon ();

2806

public unowned string get_background_icon_name ();

2807

public int get_count ();

2808

public unowned string get_label ();

2809

public unowned Gtk.StyleContext get_style_context ();

2810

public void set_background_gicon (GLib.Icon icon);

2811

public void set_background_icon_name (string icon_name);

2812

public void set_count (int count);

2813

public void set_label (string label);

2814

public void set_style_context (Gtk.StyleContext style);

2815

[CCode (type = "GIcon*", has_construct_function = false)]

2816

public NumerableIcon.with_style_context (GLib.Icon base_icon, Gtk.StyleContext context);

2817

[NoAccessorMethod]

2818

public GLib.Icon background_icon { owned get; set; }

2819

public string background_icon_name { get; set; }

2820

public int count { get; set; }

2821

public string label { get; set; }

2822

public Gtk.StyleContext style_context { get; set; }

2823

}

2824

[CCode (cheader_filename = "gtk/gtk.h")]

2603

2825

public class OffscreenWindow : Gtk.Window, Atk.Implementor, Gtk.Buildable {

2604

2826

[CCode (type = "GtkWidget*", has_construct_function = false)]

2605

2827

public OffscreenWindow ();

2992

3214

public bool get_show_fill_level ();

2993

3215

public void get_slider_range (int slider_start, int slider_end);

2994

3216

public bool get_slider_size_fixed ();

2995

public Gtk.UpdateType get_update_policy ();

2996

3217

public Gtk.SensitivityType get_upper_stepper_sensitivity ();

2997

3218

public double get_value ();

2998

3219

public void set_adjustment (Gtk.Adjustment adjustment);

3006

3227

public void set_restrict_to_fill_level (bool restrict_to_fill_level);

3007

3228

public void set_show_fill_level (bool show_fill_level);

3008

3229

public void set_slider_size_fixed (bool size_fixed);

3009

public void set_update_policy (Gtk.UpdateType policy);

3010

3230

public void set_upper_stepper_sensitivity (Gtk.SensitivityType sensitivity);

3011

3231

public void set_value (double value);

3012

3232

public Gtk.Adjustment adjustment { get; set construct; }

3015

3235

public Gtk.SensitivityType lower_stepper_sensitivity { get; set; }

3016

3236

public bool restrict_to_fill_level { get; set; }

3017

3237

public bool show_fill_level { get; set; }

3018

public Gtk.UpdateType update_policy { get; set; }

3019

3238

public Gtk.SensitivityType upper_stepper_sensitivity { get; set; }

3020

3239

public virtual signal void adjust_bounds (double new_value);

3021

3240

public virtual signal bool change_value (Gtk.ScrollType scroll, double new_value);

3199

3418

public int natural_size;

3200

3419

}

3201

3420

[CCode (cheader_filename = "gtk/gtk.h")]

3202

public class Ruler : Gtk.Widget, Atk.Implementor, Gtk.Buildable, Gtk.Orientable {

3203

[CCode (type = "GtkWidget*", has_construct_function = false)]

3204

public Ruler (Gtk.Orientation orientation);

3205

[NoWrapper]

3206

public virtual void draw_pos (Cairo.Context cr);

3207

[NoWrapper]

3208

public virtual void draw_ticks (Cairo.Context cr);

3209

public Gtk.MetricType get_metric ();

3210

public void get_range (double lower, double upper, double position, double max_size);

3211

public void set_metric (Gtk.MetricType metric);

3212

public void set_range (double lower, double upper, double position, double max_size);

3213

[NoAccessorMethod]

3214

public double lower { get; set; }

3215

[NoAccessorMethod]

3216

public double max_size { get; set; }

3217

public Gtk.MetricType metric { get; set; }

3218

[NoAccessorMethod]

3219

public double position { get; set; }

3220

[NoAccessorMethod]

3221

public double upper { get; set; }

3222

}

3223

[Compact]

3224

[CCode (cheader_filename = "gtk/gtk.h")]

3225

public class RulerMetric {

3226

public weak string abbrev;

3227

public weak string metric_name;

3228

public double pixels_per_unit;

3229

[CCode (array_length = false)]

3230

public weak double[] ruler_scale;

3231

[CCode (array_length = false)]

3232

public weak int[] subdivide;

3233

}

3234

[CCode (cheader_filename = "gtk/gtk.h")]

3235

3421

public class Scale : Gtk.Range, Atk.Implementor, Gtk.Buildable, Gtk.Orientable {

3236

3422

[CCode (type = "GtkWidget*", has_construct_function = false)]

3237

3423

public Scale (Gtk.Orientation orientation, Gtk.Adjustment adjustment);

3325

3511

[CCode (array_length = false)]

3326

3512

public unowned uchar[] get_data ();

3327

3513

public Gdk.Atom get_data_type ();

3514

public unowned uchar[] get_data_with_length (int length);

3328

3515

public unowned Gdk.Display get_display ();

3329

3516

public int get_format ();

3330

3517

public int get_length ();

3363

3550

public bool draw { get; set; }

3364

3551

}

3365

3552

[CCode (cheader_filename = "gtk/gtk.h")]

3366

public class Settings : GLib.Object {

3553

public class Settings : GLib.Object, Gtk.StyleProvider {

3367

3554

[CCode (has_construct_function = false)]

3368

3555

protected Settings ();

3369

3556

public static unowned Gtk.Settings get_default ();

3515

3702

}

3516

3703

[Compact]

3517

3704

[CCode (cheader_filename = "gtk/gtk.h")]

3518

public class SettingsPropertyValue {

3519

}

3520

[Compact]

3521

[CCode (cheader_filename = "gtk/gtk.h")]

3522

3705

public class SettingsValue {

3523

3706

public weak string origin;

3524

3707

public GLib.Value value;

3767

3950

public void @get (GLib.Type widget_type, ...);

3768

3951

public void get_style_property (GLib.Type widget_type, string property_name, out GLib.Value value);

3769

3952

public void get_valist (GLib.Type widget_type, string first_property_name, void* var_args);

3953

public bool has_context ();

3770

3954

[NoWrapper]

3771

3955

public virtual void init_from_rc (Gtk.RcStyle rc_style);

3772

3956

public bool lookup_color (string color_name, out Gdk.Color color);

3773

3957

public unowned Gtk.IconSet lookup_icon_set (string stock_id);

3774

3958

public virtual unowned Gdk.Pixbuf render_icon (Gtk.IconSource source, Gtk.TextDirection direction, Gtk.StateType state, Gtk.IconSize size, Gtk.Widget widget, string detail);

3775

3959

public virtual void set_background (Gdk.Window window, Gtk.StateType state_type);

3960

[NoAccessorMethod]

3961

public Gtk.StyleContext context { owned get; construct; }

3776

3962

public virtual signal void realize ();

3777

3963

public virtual signal void unrealize ();

3778

3964

}

3779

3965

[CCode (cheader_filename = "gtk/gtk.h")]

3966

public class StyleContext : GLib.Object {

3967

[CCode (has_construct_function = false)]

3968

public StyleContext ();

3969

public void add_class (string class_name);

3970

public void add_provider (Gtk.StyleProvider provider, uint priority);

3971

public static void add_provider_for_screen (Gdk.Screen screen, Gtk.StyleProvider provider, uint priority);

3972

public void add_region (string region_name, Gtk.RegionFlags flags);

3973

public void cancel_animations (void* region_id);

3974

public void @get (Gtk.StateFlags state);

3975

public void get_background_color (Gtk.StateFlags state, Gdk.RGBA color);

3976

public void get_border (Gtk.StateFlags state, Gtk.Border border);

3977

public void get_border_color (Gtk.StateFlags state, Gdk.RGBA color);

3978

public void get_color (Gtk.StateFlags state, Gdk.RGBA color);

3979

public Gtk.TextDirection get_direction ();

3980

public unowned Pango.FontDescription get_font (Gtk.StateFlags state);

3981

public Gtk.JunctionSides get_junction_sides ();

3982

public void get_margin (Gtk.StateFlags state, Gtk.Border margin);

3983

public void get_padding (Gtk.StateFlags state, Gtk.Border padding);

3984

public unowned Gtk.WidgetPath get_path ();

3985

public void get_property (string property, Gtk.StateFlags state, GLib.Value value);

3986

public unowned Gdk.Screen get_screen ();

3987

public Gtk.StateFlags get_state ();

3988

public void get_style ();

3989

public void get_style_property (string property_name, GLib.Value value);

3990

public void get_style_valist (void* args);

3991

public void get_valist (Gtk.StateFlags state, void* args);

3992

public bool has_class (string class_name);

3993

public bool has_region (string region_name, Gtk.RegionFlags flags_return);

3994

public void invalidate ();

3995

public unowned GLib.List list_classes ();

3996

public unowned GLib.List list_regions ();

3997

public bool lookup_color (string color_name, Gdk.RGBA color);

3998

public unowned Gtk.IconSet lookup_icon_set (string stock_id);

3999

public void notify_state_change (Gdk.Window window, void* region_id, Gtk.StateType state, bool state_value);

4000

public void pop_animatable_region ();

4001

public void push_animatable_region (void* region_id);

4002

public void remove_class (string class_name);

4003

public void remove_provider (Gtk.StyleProvider provider);

4004

public static void remove_provider_for_screen (Gdk.Screen screen, Gtk.StyleProvider provider);

4005

public void remove_region (string region_name);

4006

public static void reset_widgets (Gdk.Screen screen);

4007

public void restore ();

4008

public void save ();

4009

public void scroll_animations (Gdk.Window window, int dx, int dy);

4010

public void set_background (Gdk.Window window);

4011

public void set_direction (Gtk.TextDirection direction);

4012

public void set_junction_sides (Gtk.JunctionSides sides);

4013

public void set_path (Gtk.WidgetPath path);

4014

public void set_screen (Gdk.Screen screen);

4015

public void set_state (Gtk.StateFlags flags);

4016

public bool state_is_running (Gtk.StateType state, double progress);

4017

public Gtk.TextDirection direction { get; set; }

4018

public Gdk.Screen screen { get; set; }

4019

public virtual signal void changed ();

4020

}

4021

[CCode (cheader_filename = "gtk/gtk.h")]

4022

public class StyleProperties : GLib.Object, Gtk.StyleProvider {

4023

[CCode (has_construct_function = false)]

4024

public StyleProperties ();

4025

public void clear ();

4026

public void @get (Gtk.StateFlags state);

4027

public bool get_property (string property, Gtk.StateFlags state, GLib.Value value);

4028

public void get_valist (Gtk.StateFlags state, void* args);

4029

public unowned Gtk.SymbolicColor lookup_color (string name);

4030

public static bool lookup_property (string property_name, Gtk.StylePropertyParser parse_func, out unowned GLib.ParamSpec pspec);

4031

public void map_color (string name, Gtk.SymbolicColor color);

4032

public void merge (Gtk.StyleProperties props_to_merge, bool replace);

4033

public static void register_property (Gtk.StylePropertyParser parse_func, GLib.ParamSpec pspec);

4034

public void @set (Gtk.StateFlags state);

4035

public void set_property (string property, Gtk.StateFlags state, GLib.Value value);

4036

public void set_valist (Gtk.StateFlags state, void* args);

4037

public void unset_property (string property, Gtk.StateFlags state);

4038

}

4039

[CCode (cheader_filename = "gtk/gtk.h")]

4040

public class Switch : Gtk.Widget, Atk.Implementor, Gtk.Buildable, Gtk.Activatable {

4041

[CCode (type = "GtkWidget*", has_construct_function = false)]

4042

public Switch ();

4043

public bool get_active ();

4044

public void set_active (bool is_active);

4045

public bool active { get; set; }

4046

}

4047

[Compact]

4048

[CCode (ref_function = "gtk_symbolic_color_ref", unref_function = "gtk_symbolic_color_unref", type_id = "GTK_TYPE_SYMBOLIC_COLOR", cheader_filename = "gtk/gtk.h")]

4049

public class SymbolicColor {

4050

[CCode (has_construct_function = false)]

4051

public SymbolicColor.alpha (Gtk.SymbolicColor color, double factor);

4052

[CCode (has_construct_function = false)]

4053

public SymbolicColor.literal (Gdk.RGBA color);

4054

[CCode (has_construct_function = false)]

4055

public SymbolicColor.mix (Gtk.SymbolicColor color1, Gtk.SymbolicColor color2, double factor);

4056

[CCode (has_construct_function = false)]

4057

public SymbolicColor.name (string name);

4058

public bool resolve (Gtk.StyleProperties props, Gdk.RGBA resolved_color);

4059

[CCode (has_construct_function = false)]

4060

public SymbolicColor.shade (Gtk.SymbolicColor color, double factor);

4061

}

4062

[CCode (cheader_filename = "gtk/gtk.h")]

3780

4063

public class Table : Gtk.Container, Atk.Implementor, Gtk.Buildable {

3781

4064

[CCode (type = "GtkWidget*", has_construct_function = false)]

3782

4065

public Table (uint rows, uint columns, bool homogeneous);

3869

4152

public Gdk.Color fg_color;

3870

4153

public uint inside_selection;

3871

4154

public uint is_text;

3872

public uint pad1;

3873

public uint pad2;

3874

public uint pad3;

3875

public uint pad4;

3876

public void* padding1;

4155

[CCode (array_length = false)]

4156

public weak uint[] padding;

3877

4157

public int rise;

3878

4158

public uint strikethrough;

3879

4159

public uint underline;

3892

4172

public Gtk.Justification justification;

3893

4173

public weak Pango.Language language;

3894

4174

public int left_margin;

3895

public uint pad1;

3896

public uint pad2;

3897

public uint pad3;

3898

public uint pad4;

4175

[CCode (array_length = false)]

4176

public weak uint[] padding;

3899

4177

public Gdk.Color pg_bg_color;

3900

4178

public int pixels_above_lines;

3901

4179

public int pixels_below_lines;

4013

4291

}

4014

4292

[CCode (cheader_filename = "gtk/gtk.h")]

4015

4293

public class TextChildAnchor : GLib.Object {

4294

public void* segment;

4016

4295

[CCode (has_construct_function = false)]

4017

4296

public TextChildAnchor ();

4018

4297

public bool get_deleted ();

4020

4299

}

4021

4300

[CCode (cheader_filename = "gtk/gtk.h")]

4022

4301

public class TextMark : GLib.Object {

4302

public void* segment;

4023

4303

[CCode (has_construct_function = false)]

4024

4304

public TextMark (string name, bool left_gravity);

4025

4305

public unowned Gtk.TextBuffer get_buffer ();

4163

4443

public virtual signal bool event (GLib.Object event_object, Gdk.Event event, Gtk.TextIter iter);

4164

4444

}

4165

4445

[CCode (cheader_filename = "gtk/gtk.h")]

4166

public class TextTagTable : GLib.Object {

4446

public class TextTagTable : GLib.Object, Gtk.Buildable {

4167

4447

[CCode (has_construct_function = false)]

4168

4448

public TextTagTable ();

4169

4449

public void add (Gtk.TextTag tag);

4274

4554

public class ThemeEngine {

4275

4555

}

4276

4556

[CCode (cheader_filename = "gtk/gtk.h")]

4557

public class ThemingEngine : GLib.Object {

4558

[CCode (has_construct_function = false)]

4559

protected ThemingEngine ();

4560

public void @get (Gtk.StateFlags state);

4561

public void get_background_color (Gtk.StateFlags state, Gdk.RGBA color);

4562

public void get_border (Gtk.StateFlags state, Gtk.Border border);

4563

public void get_border_color (Gtk.StateFlags state, Gdk.RGBA color);

4564

public void get_color (Gtk.StateFlags state, Gdk.RGBA color);

4565

public Gtk.TextDirection get_direction ();

4566

public unowned Pango.FontDescription get_font (Gtk.StateFlags state);

4567

public Gtk.JunctionSides get_junction_sides ();

4568

public void get_margin (Gtk.StateFlags state, Gtk.Border margin);

4569

public void get_padding (Gtk.StateFlags state, Gtk.Border padding);

4570

public unowned Gtk.WidgetPath get_path ();

4571

public void get_property (string property, Gtk.StateFlags state, GLib.Value value);

4572

public unowned Gdk.Screen get_screen ();

4573

public Gtk.StateFlags get_state ();

4574

public void get_style ();

4575

public void get_style_property (string property_name, GLib.Value value);

4576

public void get_style_valist (void* args);

4577

public void get_valist (Gtk.StateFlags state, void* args);

4578

public bool has_class (string style_class);

4579

public bool has_region (string style_region, Gtk.RegionFlags flags);

4580

public static unowned Gtk.ThemingEngine load (string name);

4581

public bool lookup_color (string color_name, Gdk.RGBA color);

4582

public static void register_property (string name_space, Gtk.StylePropertyParser parse_func, GLib.ParamSpec pspec);

4583

[NoWrapper]

4584

public virtual void render_activity (Cairo.Context cr, double x, double y, double width, double height);

4585

[NoWrapper]

4586

public virtual void render_arrow (Cairo.Context cr, double angle, double x, double y, double size);

4587

[NoWrapper]

4588

public virtual void render_background (Cairo.Context cr, double x, double y, double width, double height);

4589

[NoWrapper]

4590

public virtual void render_check (Cairo.Context cr, double x, double y, double width, double height);

4591

[NoWrapper]

4592

public virtual void render_expander (Cairo.Context cr, double x, double y, double width, double height);

4593

[NoWrapper]

4594

public virtual void render_extension (Cairo.Context cr, double x, double y, double width, double height, Gtk.PositionType gap_side);

4595

[NoWrapper]

4596

public virtual void render_focus (Cairo.Context cr, double x, double y, double width, double height);

4597

[NoWrapper]

4598

public virtual void render_frame (Cairo.Context cr, double x, double y, double width, double height);

4599

[NoWrapper]

4600

public virtual void render_frame_gap (Cairo.Context cr, double x, double y, double width, double height, Gtk.PositionType gap_side, double xy0_gap, double xy1_gap);

4601

[NoWrapper]

4602

public virtual void render_handle (Cairo.Context cr, double x, double y, double width, double height);

4603

[NoWrapper]

4604

public virtual unowned Gdk.Pixbuf render_icon_pixbuf (Gtk.IconSource source, Gtk.IconSize size);

4605

[NoWrapper]

4606

public virtual void render_layout (Cairo.Context cr, double x, double y, Pango.Layout layout);

4607

[NoWrapper]

4608

public virtual void render_line (Cairo.Context cr, double x0, double y0, double x1, double y1);

4609

[NoWrapper]

4610

public virtual void render_option (Cairo.Context cr, double x, double y, double width, double height);

4611

[NoWrapper]

4612

public virtual void render_slider (Cairo.Context cr, double x, double y, double width, double height, Gtk.Orientation orientation);

4613

public bool state_is_running (Gtk.StateType state, double progress);

4614

[NoAccessorMethod]

4615

public string name { owned get; construct; }

4616

}

4617

[CCode (cheader_filename = "gtk/gtk.h")]

4277

4618

public class ToggleAction : Gtk.Action, Gtk.Buildable {

4278

4619

[CCode (has_construct_function = false)]

4279

4620

public ToggleAction (string name, string? label, string? tooltip, string? stock_id);

4664

5005

public int insert_column (Gtk.TreeViewColumn column, int position);

4665

5006

public int insert_column_with_attributes (int position, string? title, Gtk.CellRenderer cell, ...);

4666

5007

public int insert_column_with_data_func (int position, string title, Gtk.CellRenderer cell, owned Gtk.TreeCellDataFunc func);

5008

public bool is_blank_at_pos (int x, int y, out unowned Gtk.TreePath path, out unowned Gtk.TreeViewColumn column, int cell_x, int cell_y);

4667

5009

[CCode (cname = "gtk_tree_view_row_expanded")]

4668

5010

public bool is_row_expanded (Gtk.TreePath path);

4669

5011

public bool is_rubber_banding_active ();

4743

5085

public class TreeViewColumn : GLib.InitiallyUnowned, Gtk.CellLayout, Gtk.Buildable {

4744

5086

[CCode (has_construct_function = false)]

4745

5087

public TreeViewColumn ();

4746

public bool cell_get_position (Gtk.CellRenderer cell_renderer, int start_pos, int width);

5088

public bool cell_get_position (Gtk.CellRenderer cell_renderer, int x_offset, int width);

4747

5089

public void cell_get_size (out Gdk.Rectangle cell_area, out int x_offset, out int y_offset, out int width, out int height);

4748

5090

public bool cell_is_visible ();

4749

5091

public void cell_set_cell_data (Gtk.TreeModel tree_model, Gtk.TreeIter iter, bool is_expander, bool is_expanded);

4750

5092

public void focus_cell (Gtk.CellRenderer cell);

4751

5093

public float get_alignment ();

5094

public unowned Gtk.Widget get_button ();

4752

5095

public bool get_clickable ();

4753

5096

public bool get_expand ();

4754

5097

public int get_fixed_width ();

4785

5128

public void set_visible (bool visible);

4786

5129

public void set_widget (Gtk.Widget widget);

4787

5130

[CCode (has_construct_function = false)]

5131

public TreeViewColumn.with_area (Gtk.CellArea area);

5132

[CCode (has_construct_function = false)]

4788

5133

public TreeViewColumn.with_attributes (string? title, Gtk.CellRenderer cell, ...);

4789

5134

public float alignment { get; set; }

5135

[NoAccessorMethod]

5136

public Gtk.CellArea cell_area { owned get; construct; }

4790

5137

public bool clickable { get; set; }

4791

5138

public bool expand { get; set; }

4792

5139

public int fixed_width { get; set; }

4851

5198

public VPaned ();

4852

5199

}

4853

5200

[CCode (cheader_filename = "gtk/gtk.h")]

4854

public class VRuler : Gtk.Ruler, Atk.Implementor, Gtk.Buildable, Gtk.Orientable {

4855

[CCode (type = "GtkWidget*", has_construct_function = false)]

4856

public VRuler ();

4857

}

4858

[CCode (cheader_filename = "gtk/gtk.h")]

4859

5201

public class VScale : Gtk.Scale, Atk.Implementor, Gtk.Buildable, Gtk.Orientable {

4860

5202

[CCode (type = "GtkWidget*", has_construct_function = false)]

4861

5203

public VScale (Gtk.Adjustment? adjustment);

4890

5232

public class VolumeButton : Gtk.ScaleButton, Atk.Implementor, Gtk.Buildable, Gtk.Activatable, Gtk.Orientable {

4891

5233

[CCode (type = "GtkWidget*", has_construct_function = false)]

4892

5234

public VolumeButton ();

5235

[NoAccessorMethod]

5236

public bool use_symbolic { get; set; }

4893

5237

}

4894

5238

[CCode (cheader_filename = "gtk/gtk.h")]

4895

5239

public class Widget : GLib.InitiallyUnowned, Atk.Implementor, Gtk.Buildable {

4901

5245

public void add_events (int events);

4902

5246

public void add_mnemonic_label (Gtk.Widget label);

4903

5247

[NoWrapper]

4904

public virtual void adjust_size_allocation (Gtk.Orientation orientation, int natural_size, int allocated_pos, int allocated_size);

5248

public virtual void adjust_size_allocation (Gtk.Orientation orientation, int minimum_size, int natural_size, int allocated_pos, int allocated_size);

4905

5249

[NoWrapper]

4906

5250

public virtual void adjust_size_request (Gtk.Orientation orientation, int minimum_size, int natural_size);

4907

5251

public bool child_focus (Gtk.DirectionType direction);

4931

5275

public unowned string get_composite_name ();

4932

5276

public static Gtk.TextDirection get_default_direction ();

4933

5277

public static unowned Gtk.Style get_default_style ();

5278

public bool get_device_enabled (Gdk.Device device);

4934

5279

public Gdk.EventMask get_device_events (Gdk.Device device);

4935

5280

public Gtk.TextDirection get_direction ();

4936

5281

public unowned Gdk.Display get_display ();

4937

5282

public bool get_double_buffered ();

4938

5283

public int get_events ();

4939

public Gdk.ExtensionMode get_extension_events ();

4940

5284

public Gtk.Align get_halign ();

4941

5285

public bool get_has_tooltip ();

4942

5286

public bool get_has_window ();

4952

5296

public unowned Pango.Context get_pango_context ();

4953

5297

public unowned Gtk.Widget get_parent ();

4954

5298

public unowned Gdk.Window get_parent_window ();

5299

public unowned Gtk.WidgetPath get_path ();

4955

5300

public void get_pointer (out int x, out int y);

4956

5301

public virtual void get_preferred_height (int minimum_height, int natural_height);

4957

5302

public virtual void get_preferred_height_for_width (int width, int minimum_height, int natural_height);

4968

5313

public unowned Gtk.Settings get_settings ();

4969

5314

public void get_size_request (out int width, out int height);

4970

5315

public Gtk.StateType get_state ();

5316

public Gtk.StateFlags get_state_flags ();

4971

5317

public unowned Gtk.Style get_style ();

5318

public unowned Gtk.StyleContext get_style_context ();

4972

5319

public bool get_support_multidevice ();

4973

5320

public unowned string get_tooltip_markup ();

4974

5321

public unowned string get_tooltip_text ();

5005

5352

public void modify_fg (Gtk.StateType state, Gdk.Color? color);

5006

5353

public void modify_font (Pango.FontDescription? font_desc);

5007

5354

public void modify_style (Gtk.RcStyle style);

5008

public void modify_symbolic_color (string name, Gdk.Color color);

5009

5355

public void modify_text (Gtk.StateType state, Gdk.Color? color);

5356

public void override_background_color (Gtk.StateFlags state, Gdk.RGBA color);

5357

public void override_color (Gtk.StateFlags state, Gdk.RGBA color);

5358

public void override_cursor (Gdk.RGBA cursor, Gdk.RGBA secondary_cursor);

5359

public void override_font (Pango.FontDescription font_desc);

5360

public void override_symbolic_color (string name, Gdk.RGBA color);

5010

5361

public void path (out uint path_length, out unowned string path, out unowned string path_reversed);

5011

5362

public static void pop_composite_child ();

5012

5363

public static void push_composite_child ();

5020

5371

public bool remove_accelerator (Gtk.AccelGroup accel_group, uint accel_key, Gdk.ModifierType accel_mods);

5021

5372

public void remove_mnemonic_label (Gtk.Widget label);

5022

5373

public Gdk.Pixbuf render_icon (string stock_id, Gtk.IconSize size, string? detail);

5374

public unowned Gdk.Pixbuf render_icon_pixbuf (string stock_id, Gtk.IconSize size);

5023

5375

public void reparent (Gtk.Widget new_parent);

5024

5376

public void reset_rc_styles ();

5025

public void reset_shapes ();

5377

public void reset_style ();

5026

5378

public int send_expose (Gdk.Event event);

5027

5379

public bool send_focus_change (Gdk.Event event);

5028

5380

public void set_accel_path (string accel_path, Gtk.AccelGroup accel_group);

5033

5385

public void set_child_visible (bool is_visible);

5034

5386

public void set_composite_name (string name);

5035

5387

public static void set_default_direction (Gtk.TextDirection dir);

5388

public void set_device_enabled (Gdk.Device device, bool enabled);

5036

5389

public void set_device_events (Gdk.Device device, Gdk.EventMask events);

5037

5390

public void set_direction (Gtk.TextDirection dir);

5038

5391

public void set_double_buffered (bool double_buffered);

5039

5392

public void set_events (int events);

5040

public void set_extension_events (Gdk.ExtensionMode mode);

5041

5393

public void set_halign (Gtk.Align align);

5042

5394

public void set_has_tooltip (bool has_tooltip);

5043

5395

public void set_has_window (bool has_window);

5057

5409

public void set_sensitive (bool sensitive);

5058

5410

public void set_size_request (int width, int height);

5059

5411

public void set_state (Gtk.StateType state);

5412

public void set_state_flags (Gtk.StateFlags flags, bool clear);

5060

5413

public void set_style (Gtk.Style? style);

5061

5414

public void set_support_multidevice (bool support_multidevice);

5062

5415

public void set_tooltip_markup (string markup);

5079

5432

public bool translate_coordinates (Gtk.Widget dest_widget, int src_x, int src_y, out int dest_x, out int dest_y);

5080

5433

public void trigger_tooltip_query ();

5081

5434

public void unparent ();

5435

public void unset_state_flags (Gtk.StateFlags flags);

5082

5436

public bool app_paintable { get; set; }

5083

5437

public bool can_default { get; set; }

5084

5438

[NoAccessorMethod]

5089

5443

public Gdk.EventMask events { get; set; }

5090

5444

[NoAccessorMethod]

5091

5445

public bool expand { get; set; }

5092

public Gdk.ExtensionMode extension_events { get; set; }

5093

5446

public Gtk.Align halign { get; set; }

5094

5447

[NoAccessorMethod]

5095

5448

public bool has_default { get; set; }

5134

5487

public virtual signal bool configure_event (Gdk.EventConfigure event);

5135

5488

public virtual signal bool damage_event (Gdk.Event event);

5136

5489

public virtual signal bool delete_event (Gdk.Event event);

5490

[HasEmitter]

5137

5491

public virtual signal void destroy ();

5138

5492

public virtual signal bool destroy_event (Gdk.Event event);

5139

5493

public virtual signal void direction_changed (Gtk.TextDirection previous_direction);

5143

5497

public virtual signal void drag_data_received (Gdk.DragContext context, int x, int y, Gtk.SelectionData selection_data, uint info, uint time_);

5144

5498

public virtual signal bool drag_drop (Gdk.DragContext context, int x, int y, uint time_);

5145

5499

public virtual signal void drag_end (Gdk.DragContext context);

5146

public virtual signal bool drag_failed (Gdk.DragContext p0, Gtk.DragResult p1);

5500

public virtual signal bool drag_failed (Gdk.DragContext context, Gtk.DragResult result);

5147

5501

public virtual signal void drag_leave (Gdk.DragContext context, uint time_);

5148

5502

public virtual signal bool drag_motion (Gdk.DragContext context, int x, int y, uint time_);

5149

5503

[HasEmitter]

5174

5528

public virtual signal bool mnemonic_activate (bool group_cycling);

5175

5529

public virtual signal bool motion_notify_event (Gdk.EventMotion event);

5176

5530

public virtual signal void move_focus (Gtk.DirectionType direction);

5177

public virtual signal bool no_expose_event (Gdk.EventNoExpose event);

5178

5531

public virtual signal void parent_set (Gtk.Widget? previous_parent);

5179

5532

public virtual signal bool popup_menu ();

5180

5533

public virtual signal bool property_notify_event (Gdk.EventProperty event);

5195

5548

public virtual signal bool show_help (Gtk.WidgetHelpType help_type);

5196

5549

[HasEmitter]

5197

5550

public virtual signal void size_allocate (Gdk.Rectangle allocation);

5198

[HasEmitter]

5199

public virtual signal void size_request (out Gtk.Requisition requisition);

5200

5551

public virtual signal void state_changed (Gtk.StateType previous_state);

5552

public virtual signal void state_flags_changed (Gtk.StateFlags previous_state_flags);

5201

5553

public virtual signal void style_set (Gtk.Style? previous_style);

5554

public virtual signal void style_updated ();

5202

5555

[HasEmitter]

5203

5556

public virtual signal void unmap ();

5204

5557

public virtual signal bool unmap_event (Gdk.Event event);

5216

5569

public uint valign;

5217

5570

public int width;

5218

5571

}

5572

[Compact]

5573

[CCode (copy_function = "gtk_widget_path_copy", type_id = "GTK_TYPE_WIDGET_PATH", cheader_filename = "gtk/gtk.h")]

5574

public class WidgetPath {

5575

[CCode (has_construct_function = false)]

5576

public WidgetPath ();

5577

public int append_type (GLib.Type type);

5578

public unowned Gtk.WidgetPath copy ();

5579

public GLib.Type get_object_type ();

5580

public bool has_parent (GLib.Type type);

5581

public bool is_type (GLib.Type type);

5582

public void iter_add_class (int pos, string name);

5583

public void iter_add_region (int pos, string name, Gtk.RegionFlags flags);

5584

public void iter_clear_classes (int pos);

5585

public void iter_clear_regions (int pos);

5586

public unowned string iter_get_name (int pos);

5587

public GLib.Type iter_get_object_type (int pos);

5588

public bool iter_has_class (int pos, string name);

5589

public bool iter_has_name (int pos, string name);

5590

public bool iter_has_qclass (int pos, GLib.Quark qname);

5591

public bool iter_has_qname (int pos, GLib.Quark qname);

5592

public bool iter_has_qregion (int pos, GLib.Quark qname, Gtk.RegionFlags flags);

5593

public bool iter_has_region (int pos, string name, Gtk.RegionFlags flags);

5594

public unowned GLib.SList iter_list_classes (int pos);

5595

public unowned GLib.SList iter_list_regions (int pos);

5596

public void iter_remove_class (int pos, string name);

5597

public void iter_remove_region (int pos, string name);

5598

public void iter_set_name (int pos, string name);

5599

public void iter_set_object_type (int pos, GLib.Type type);

5600

public int length ();

5601

public void prepend_type (GLib.Type type);

5602

}

5219

5603

[CCode (cheader_filename = "gtk/gtk.h")]

5220

5604

public class Window : Gtk.Bin, Atk.Implementor, Gtk.Buildable {

5221

5605

[CCode (type = "GtkWidget*", has_construct_function = false)]

5224

5608

public bool activate_focus ();

5225

5609

public bool activate_key (Gdk.EventKey event);

5226

5610

public void add_accel_group (Gtk.AccelGroup accel_group);

5227

public void add_embedded_xid (Gdk.NativeWindow xid);

5228

5611

public void add_mnemonic (uint keyval, Gtk.Widget target);

5229

5612

public void begin_move_drag (int button, int root_x, int root_y, uint32 timestamp);

5230

5613

public void begin_resize_drag (Gdk.WindowEdge edge, int button, int root_x, int root_y, uint32 timestamp);

5241

5624

public bool get_destroy_with_parent ();

5242

5625

public unowned Gtk.Widget get_focus ();

5243

5626

public bool get_focus_on_map ();

5244

public void get_frame_dimensions (int left, int top, int right, int bottom);

5245

5627

public Gdk.Gravity get_gravity ();

5246

5628

public unowned Gtk.WindowGroup get_group ();

5247

public bool get_has_frame ();

5248

5629

public bool get_has_resize_grip ();

5249

5630

public unowned Gdk.Pixbuf get_icon ();

5250

5631

public GLib.List<weak Gdk.Pixbuf> get_icon_list ();

5277

5658

public void present_with_time (uint32 timestamp);

5278

5659

public bool propagate_key_event (Gdk.EventKey event);

5279

5660

public void remove_accel_group (Gtk.AccelGroup accel_group);

5280

public void remove_embedded_xid (Gdk.NativeWindow xid);

5281

5661

public void remove_mnemonic (uint keyval, Gtk.Widget target);

5282

5662

public void reshow_with_initial_size ();

5283

5663

public void resize (int width, int height);

5297

5677

public void set_deletable (bool setting);

5298

5678

public void set_destroy_with_parent (bool setting);

5299

5679

public void set_focus_on_map (bool setting);

5300

public void set_frame_dimensions (int left, int top, int right, int bottom);

5301

5680

public void set_geometry_hints (Gtk.Widget geometry_widget, Gdk.Geometry geometry, Gdk.WindowHints geom_mask);

5302

5681

public void set_gravity (Gdk.Gravity gravity);

5303

public void set_has_frame (bool setting);

5304

5682

public void set_has_resize_grip (bool value);

5683

public void set_has_user_ref_count (bool setting);

5305

5684

public void set_icon (Gdk.Pixbuf icon);

5306

5685

public bool set_icon_from_file (string filename) throws GLib.Error;

5307

5686

public void set_icon_list (GLib.List<Gdk.Pixbuf> list);

5367

5746

public Gtk.WindowPosition window_position { get; set; }

5368

5747

public virtual signal void default_activated ();

5369

5748

public virtual signal void focus_activated ();

5370

public virtual signal bool frame_event (Gdk.Event event);

5371

5749

public virtual signal void keys_changed ();

5372

5750

[HasEmitter]

5373

5751

public virtual signal void set_focus (Gtk.Widget? focus);

5400

5778

public bool use_action_appearance { get; set; }

5401

5779

}

5402

5780

[CCode (cheader_filename = "gtk/gtk.h")]

5781

public interface AppChooser : Gtk.Widget {

5782

public unowned GLib.AppInfo get_app_info ();

5783

public unowned string get_content_type ();

5784

public void refresh ();

5785

public string content_type { get; construct; }

5786

}

5787

[CCode (cheader_filename = "gtk/gtk.h")]

5403

5788

public interface Buildable : GLib.Object {

5404

5789

public abstract void add_child (Gtk.Builder builder, GLib.Object child, string? type);

5405

5790

public abstract unowned GLib.Object construct_child (Gtk.Builder builder, string name);

5426

5811

public abstract void add_attribute (Gtk.CellRenderer cell, string attribute, int column);

5427

5812

public abstract void clear ();

5428

5813

public abstract void clear_attributes (Gtk.CellRenderer cell);

5814

public abstract unowned Gtk.CellArea get_area ();

5429

5815

public abstract GLib.List<weak Gtk.CellRenderer> get_cells ();

5430

5816

public abstract void pack_end (Gtk.CellRenderer cell, bool expand);

5431

5817

public abstract void pack_start (Gtk.CellRenderer cell, bool expand);

5617

6003

public Gtk.ScrollablePolicy vscroll_policy { get; set; }

5618

6004

}

5619

6005

[CCode (cheader_filename = "gtk/gtk.h")]

6006

public interface StyleProvider {

6007

public abstract unowned Gtk.IconFactory get_icon_factory (Gtk.WidgetPath path);

6008

public abstract unowned Gtk.StyleProperties get_style (Gtk.WidgetPath path);

6009

public abstract bool get_style_property (Gtk.WidgetPath path, Gtk.StateFlags state, GLib.ParamSpec pspec, GLib.Value value);

6010

}

6011

[CCode (cheader_filename = "gtk/gtk.h")]

5620

6012

public interface ToolShell : Gtk.Widget {

5621

6013

public abstract Pango.EllipsizeMode get_ellipsize_mode ();

5622

6014

public abstract Gtk.IconSize get_icon_size ();

5660

6052

public abstract bool iter_next (ref Gtk.TreeIter iter);

5661

6053

public abstract bool iter_nth_child (out Gtk.TreeIter iter, Gtk.TreeIter? parent, int n);

5662

6054

public abstract bool iter_parent (out Gtk.TreeIter iter, Gtk.TreeIter child);

6055

public virtual bool iter_previous (ref Gtk.TreeIter iter);

5663

6056

public abstract void ref_node (Gtk.TreeIter iter);

5664

6057

public abstract void unref_node (Gtk.TreeIter iter);

5665

6058

[HasEmitter]

5932

6325

SHRINK,

5933

6326

FILL

5934

6327

}

6328

[CCode (cprefix = "GTK_BORDER_STYLE_", cheader_filename = "gtk/gtk.h")]

6329

public enum BorderStyle {

6330

NONE,

6331

SOLID,

6332

INSET,

6333

OUTSET

6334

}

5935

6335

[CCode (cprefix = "GTK_BUTTONBOX_", cheader_filename = "gtk/gtk.h")]

5936

6336

public enum ButtonBoxStyle {

5937

6337

SPREAD,

5985

6385

TOP_RIGHT,

5986

6386

BOTTOM_RIGHT

5987

6387

}

6388

[CCode (cprefix = "GTK_CSS_PROVIDER_ERROR_", cheader_filename = "gtk/gtk.h")]

6389

public enum CssProviderError {

6390

FAILED

6391

}

5988

6392

[CCode (cprefix = "GTK_DEBUG_", cheader_filename = "gtk/gtk.h")]

5989

6393

[Flags]

5990

6394

public enum DebugFlag {

6140

6544

ICON_NAME,

6141

6545

GICON

6142

6546

}

6547

[CCode (cprefix = "GTK_JUNCTION_", cheader_filename = "gtk/gtk.h")]

6548

[Flags]

6549

public enum JunctionSides {

6550

NONE,

6551

CORNER_TOPLEFT,

6552

CORNER_TOPRIGHT,

6553

CORNER_BOTTOMLEFT,

6554

CORNER_BOTTOMRIGHT,

6555

TOP,

6556

BOTTOM,

6557

LEFT,

6558

RIGHT

6559

}

6143

6560

[CCode (cprefix = "GTK_JUSTIFY_", cheader_filename = "gtk/gtk.h")]

6144

6561

public enum Justification {

6145

6562

LEFT,

6174

6591

ERROR,

6175

6592

OTHER

6176

6593

}

6177

[CCode (cprefix = "GTK_", cheader_filename = "gtk/gtk.h")]

6178

public enum MetricType {

6179

PIXELS,

6180

INCHES,

6181

CENTIMETERS

6182

}

6183

6594

[CCode (cprefix = "GTK_MOVEMENT_", cheader_filename = "gtk/gtk.h")]

6184

6595

public enum MovementStep {

6185

6596

LOGICAL_POSITIONS,

6403

6814

LRU,

6404

6815

CUSTOM

6405

6816

}

6817

[CCode (cprefix = "GTK_REGION_", cheader_filename = "gtk/gtk.h")]

6818

[Flags]

6819

public enum RegionFlags {

6820

EVEN,

6821

ODD,

6822

FIRST,

6823

LAST,

6824

SORTED

6825

}

6406

6826

[CCode (cprefix = "GTK_RELIEF_", cheader_filename = "gtk/gtk.h")]

6407

6827

public enum ReliefStyle {

6408

6828

NORMAL,

6515

6935

END,

6516

6936

USER_DEFINED

6517

6937

}

6938

[CCode (cprefix = "GTK_STATE_FLAG_", cheader_filename = "gtk/gtk.h")]

6939

[Flags]

6940

public enum StateFlags {

6941

NORMAL,

6942

ACTIVE,

6943

PRELIGHT,

6944

SELECTED,

6945

INSENSITIVE,

6946

INCONSISTENT,

6947

FOCUSED

6948

}

6518

6949

[CCode (cprefix = "GTK_STATE_", cheader_filename = "gtk/gtk.h")]

6519

6950

public enum StateType {

6520

6951

NORMAL,

6521

6952

ACTIVE,

6522

6953

PRELIGHT,

6523

6954

SELECTED,

6524

INSENSITIVE

6955

INSENSITIVE,

6956

INCONSISTENT,

6957

FOCUSED

6525

6958

}

6526

6959

[CCode (cprefix = "GTK_TARGET_", cheader_filename = "gtk/gtk.h")]

6527

6960

[Flags]

6626

7059

INCH,

6627

7060

6628

7061

}

6629

[CCode (cprefix = "GTK_UPDATE_", cheader_filename = "gtk/gtk.h")]

6630

public enum UpdateType {

6631

CONTINUOUS,

6632

DISCONTINUOUS,

6633

DELAYED

6634

}

6635

7062

[CCode (cprefix = "GTK_WIDGET_HELP_", cheader_filename = "gtk/gtk.h")]

6636

7063

public enum WidgetHelpType {

6637

7064

TOOLTIP,

6685

7112

public delegate string CalendarDetailFunc (Gtk.Calendar calendar, uint year, uint month, uint day);

6686

7113

[CCode (cheader_filename = "gtk/gtk.h")]

6687

7114

public delegate void Callback (Gtk.Widget widget);

6688

[CCode (cheader_filename = "gtk/gtk.h", has_target = false)]

6689

public delegate void CallbackMarshal (GLib.Object object, void* data, Gtk.Arg[] args);

7115

[CCode (cheader_filename = "gtk/gtk.h")]

7116

public delegate bool CellAllocCallback (Gtk.CellRenderer renderer, Gdk.Rectangle cell_area, Gdk.Rectangle cell_background);

7117

[CCode (cheader_filename = "gtk/gtk.h")]

7118

public delegate bool CellCallback (Gtk.CellRenderer renderer);

6690

7119

[CCode (cheader_filename = "gtk/gtk.h")]

6691

7120

public delegate void CellLayoutDataFunc (Gtk.CellLayout cell_layout, Gtk.CellRenderer cell, Gtk.TreeModel tree_model, Gtk.TreeIter iter);

6692

7121

[CCode (cheader_filename = "gtk/gtk.h", has_target = false)]

6714

7143

[CCode (cheader_filename = "gtk/gtk.h")]

6715

7144

public delegate bool FileFilterFunc (Gtk.FileFilterInfo filter_info);

6716

7145

[CCode (cheader_filename = "gtk/gtk.h")]

6717

public delegate bool Function ();

6718

[CCode (cheader_filename = "gtk/gtk.h")]

6719

7146

public delegate void IconViewForeachFunc (Gtk.IconView icon_view, Gtk.TreePath path);

6720

7147

[CCode (cheader_filename = "gtk/gtk.h", has_target = false)]

6721

7148

public delegate int KeySnoopFunc (Gtk.Widget grab_widget, Gdk.EventKey event, void* func_data);

6739

7166

public delegate bool RecentFilterFunc (Gtk.RecentFilterInfo filter_info);

6740

7167

[CCode (cheader_filename = "gtk/gtk.h")]

6741

7168

public delegate int RecentSortFunc (Gtk.RecentInfo a, Gtk.RecentInfo b);

7169

[CCode (cheader_filename = "gtk/gtk.h", has_target = false)]

7170

public delegate bool StylePropertyParser (string str, GLib.Value value, GLib.Error error);

6742

7171

[CCode (cheader_filename = "gtk/gtk.h")]

6743

7172

public delegate bool TextBufferDeserializeFunc (Gtk.TextBuffer register_buffer, Gtk.TextBuffer content_buffer, Gtk.TextIter iter, uchar data, size_t length, bool create_tags, GLib.Error error);

6744

7173

[CCode (cheader_filename = "gtk/gtk.h")]

6776

7205

[CCode (cheader_filename = "gtk/gtk.h")]

6777

7206

public delegate void TreeViewSearchPositionFunc (Gtk.TreeView tree_view, Gtk.Widget search_dialog);

6778

7207

[CCode (cheader_filename = "gtk/gtk.h")]

6779

public delegate void WindowKeysForeachFunc (Gtk.Window window, uint keyval, Gdk.ModifierType modifiers, bool is_mnemonic);

6780

[CCode (cheader_filename = "gtk/gtk.h")]

6781

7208

public const int BINARY_AGE;

6782

7209

[CCode (cheader_filename = "gtk/gtk.h")]

6783

7210

public const int INPUT_ERROR;

7185

7612

[CCode (cheader_filename = "gtk/gtk.h")]

7186

7613

public const string STOCK_ZOOM_OUT;

7187

7614

[CCode (cheader_filename = "gtk/gtk.h")]

7615

public const string STYLE_CLASS_ACCELERATOR;

7616

[CCode (cheader_filename = "gtk/gtk.h")]

7617

public const string STYLE_CLASS_BACKGROUND;

7618

[CCode (cheader_filename = "gtk/gtk.h")]

7619

public const string STYLE_CLASS_BUTTON;

7620

[CCode (cheader_filename = "gtk/gtk.h")]

7621

public const string STYLE_CLASS_CALENDAR;

7622

[CCode (cheader_filename = "gtk/gtk.h")]

7623

public const string STYLE_CLASS_CELL;

7624

[CCode (cheader_filename = "gtk/gtk.h")]

7625

public const string STYLE_CLASS_CHECK;

7626

[CCode (cheader_filename = "gtk/gtk.h")]

7627

public const string STYLE_CLASS_DEFAULT;

7628

[CCode (cheader_filename = "gtk/gtk.h")]

7629

public const string STYLE_CLASS_DND;

7630

[CCode (cheader_filename = "gtk/gtk.h")]

7631

public const string STYLE_CLASS_DOCK;

7632

[CCode (cheader_filename = "gtk/gtk.h")]

7633

public const string STYLE_CLASS_ENTRY;

7634

[CCode (cheader_filename = "gtk/gtk.h")]

7635

public const string STYLE_CLASS_ERROR;

7636

[CCode (cheader_filename = "gtk/gtk.h")]

7637

public const string STYLE_CLASS_EXPANDER;

7638

[CCode (cheader_filename = "gtk/gtk.h")]

7639

public const string STYLE_CLASS_FRAME;

7640

[CCode (cheader_filename = "gtk/gtk.h")]

7641

public const string STYLE_CLASS_GRIP;

7642

[CCode (cheader_filename = "gtk/gtk.h")]

7643

public const string STYLE_CLASS_HEADER;

7644

[CCode (cheader_filename = "gtk/gtk.h")]

7645

public const string STYLE_CLASS_HIGHLIGHT;

7646

[CCode (cheader_filename = "gtk/gtk.h")]

7647

public const string STYLE_CLASS_HORIZONTAL;

7648

[CCode (cheader_filename = "gtk/gtk.h")]

7649

public const string STYLE_CLASS_INFO;

7650

[CCode (cheader_filename = "gtk/gtk.h")]

7651

public const string STYLE_CLASS_MARK;

7652

[CCode (cheader_filename = "gtk/gtk.h")]

7653

public const string STYLE_CLASS_MENU;

7654

[CCode (cheader_filename = "gtk/gtk.h")]

7655

public const string STYLE_CLASS_MENUBAR;

7656

[CCode (cheader_filename = "gtk/gtk.h")]

7657

public const string STYLE_CLASS_MENUITEM;

7658

[CCode (cheader_filename = "gtk/gtk.h")]

7659

public const string STYLE_CLASS_NOTEBOOK;

7660

[CCode (cheader_filename = "gtk/gtk.h")]

7661

public const string STYLE_CLASS_PANE_SEPARATOR;

7662

[CCode (cheader_filename = "gtk/gtk.h")]

7663

public const string STYLE_CLASS_PROGRESSBAR;

7664

[CCode (cheader_filename = "gtk/gtk.h")]

7665

public const string STYLE_CLASS_QUESTION;

7666

[CCode (cheader_filename = "gtk/gtk.h")]

7667

public const string STYLE_CLASS_RADIO;

7668

[CCode (cheader_filename = "gtk/gtk.h")]

7669

public const string STYLE_CLASS_RUBBERBAND;

7670

[CCode (cheader_filename = "gtk/gtk.h")]

7671

public const string STYLE_CLASS_SCALE;

7672

[CCode (cheader_filename = "gtk/gtk.h")]

7673

public const string STYLE_CLASS_SCROLLBAR;

7674

[CCode (cheader_filename = "gtk/gtk.h")]

7675

public const string STYLE_CLASS_SLIDER;

7676

[CCode (cheader_filename = "gtk/gtk.h")]

7677

public const string STYLE_CLASS_SPINBUTTON;

7678

[CCode (cheader_filename = "gtk/gtk.h")]

7679

public const string STYLE_CLASS_SPINNER;

7680

[CCode (cheader_filename = "gtk/gtk.h")]

7681

public const string STYLE_CLASS_TOOLBAR;

7682

[CCode (cheader_filename = "gtk/gtk.h")]

7683

public const string STYLE_CLASS_TOOLTIP;

7684

[CCode (cheader_filename = "gtk/gtk.h")]

7685

public const string STYLE_CLASS_TROUGH;

7686

[CCode (cheader_filename = "gtk/gtk.h")]

7687

public const string STYLE_CLASS_VERTICAL;

7688

[CCode (cheader_filename = "gtk/gtk.h")]

7689

public const string STYLE_CLASS_VIEW;

7690

[CCode (cheader_filename = "gtk/gtk.h")]

7691

public const string STYLE_CLASS_WARNING;

7692

[CCode (cheader_filename = "gtk/gtk.h")]

7693

public const string STYLE_PROPERTY_BACKGROUND_COLOR;

7694

[CCode (cheader_filename = "gtk/gtk.h")]

7695

public const string STYLE_PROPERTY_BACKGROUND_IMAGE;

7696

[CCode (cheader_filename = "gtk/gtk.h")]

7697

public const string STYLE_PROPERTY_BORDER_COLOR;

7698

[CCode (cheader_filename = "gtk/gtk.h")]

7699

public const string STYLE_PROPERTY_BORDER_RADIUS;

7700

[CCode (cheader_filename = "gtk/gtk.h")]

7701

public const string STYLE_PROPERTY_BORDER_STYLE;

7702

[CCode (cheader_filename = "gtk/gtk.h")]

7703

public const string STYLE_PROPERTY_BORDER_WIDTH;

7704

[CCode (cheader_filename = "gtk/gtk.h")]

7705

public const string STYLE_PROPERTY_COLOR;

7706

[CCode (cheader_filename = "gtk/gtk.h")]

7707

public const string STYLE_PROPERTY_FONT;

7708

[CCode (cheader_filename = "gtk/gtk.h")]

7709

public const string STYLE_PROPERTY_MARGIN;

7710

[CCode (cheader_filename = "gtk/gtk.h")]

7711

public const string STYLE_PROPERTY_PADDING;

7712

[CCode (cheader_filename = "gtk/gtk.h")]

7713

public const int STYLE_PROVIDER_PRIORITY_APPLICATION;

7714

[CCode (cheader_filename = "gtk/gtk.h")]

7715

public const int STYLE_PROVIDER_PRIORITY_FALLBACK;

7716

[CCode (cheader_filename = "gtk/gtk.h")]

7717

public const int STYLE_PROVIDER_PRIORITY_SETTINGS;

7718

[CCode (cheader_filename = "gtk/gtk.h")]

7719

public const int STYLE_PROVIDER_PRIORITY_THEME;

7720

[CCode (cheader_filename = "gtk/gtk.h")]

7721

public const int STYLE_PROVIDER_PRIORITY_USER;

7722

[CCode (cheader_filename = "gtk/gtk.h")]

7723

public const string STYLE_REGION_COLUMN;

7724

[CCode (cheader_filename = "gtk/gtk.h")]

7725

public const string STYLE_REGION_COLUMN_HEADER;

7726

[CCode (cheader_filename = "gtk/gtk.h")]

7727

public const string STYLE_REGION_ROW;

7728

[CCode (cheader_filename = "gtk/gtk.h")]

7729

public const string STYLE_REGION_TAB;

7730

[CCode (cheader_filename = "gtk/gtk.h")]

7188

7731

public const int TEXT_VIEW_PRIORITY_VALIDATE;

7189

7732

[CCode (cheader_filename = "gtk/gtk.h")]

7190

7733

public static bool accel_groups_activate (GLib.Object object, uint accel_key, Gdk.ModifierType accel_mods);

7339

7882

[CCode (cheader_filename = "gtk/gtk.h")]

7340

7883

public static void icon_size_register_alias (string alias, Gtk.IconSize target);

7341

7884

[CCode (cheader_filename = "gtk/gtk.h")]

7342

public static GLib.Type identifier_get_type ();

7343

[CCode (cheader_filename = "gtk/gtk.h")]

7344

7885

public static void init ([CCode (array_length_pos = 0.9)] ref unowned string[] argv);

7345

7886

[CCode (cheader_filename = "gtk/gtk.h")]

7346

public static void init_add (Gtk.Function function);

7347

[CCode (cheader_filename = "gtk/gtk.h")]

7348

7887

public static bool init_check ([CCode (array_length_pos = 0.9)] ref unowned string[] argv);

7349

7888

[CCode (cheader_filename = "gtk/gtk.h")]

7350

7889

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;

7415

7954

[CCode (cheader_filename = "gtk/gtk.h")]

7416

7955

public static void propagate_event (Gtk.Widget widget, Gdk.Event event);

7417

7956

[CCode (cheader_filename = "gtk/gtk.h")]

7418

public static uint quit_add (uint main_level, Gtk.Function function);

7419

[CCode (cheader_filename = "gtk/gtk.h")]

7420

public static void quit_add_destroy (uint main_level, Gtk.Widget object);

7421

[CCode (cheader_filename = "gtk/gtk.h")]

7422

public static void quit_remove (uint quit_handler_id);

7423

[CCode (cheader_filename = "gtk/gtk.h")]

7424

public static void quit_remove_by_data (void* data);

7425

[CCode (cheader_filename = "gtk/gtk.h")]

7426

7957

public static void rc_add_default_file (string filename);

7427

7958

[CCode (cheader_filename = "gtk/gtk.h")]

7428

7959

public static unowned string rc_find_module_in_path (string module_file);

7465

7996

[CCode (cheader_filename = "gtk/gtk.h")]

7466

7997

public static void rc_set_default_files (string filenames);

7467

7998

[CCode (cheader_filename = "gtk/gtk.h")]

7999

public static void render_activity (Gtk.StyleContext context, Cairo.Context cr, double x, double y, double width, double height);

8000

[CCode (cheader_filename = "gtk/gtk.h")]

8001

public static void render_arrow (Gtk.StyleContext context, Cairo.Context cr, double angle, double x, double y, double size);

8002

[CCode (cheader_filename = "gtk/gtk.h")]

8003

public static void render_background (Gtk.StyleContext context, Cairo.Context cr, double x, double y, double width, double height);

8004

[CCode (cheader_filename = "gtk/gtk.h")]

8005

public static void render_check (Gtk.StyleContext context, Cairo.Context cr, double x, double y, double width, double height);

8006

[CCode (cheader_filename = "gtk/gtk.h")]

8007

public static void render_expander (Gtk.StyleContext context, Cairo.Context cr, double x, double y, double width, double height);

8008

[CCode (cheader_filename = "gtk/gtk.h")]

8009

public static void render_extension (Gtk.StyleContext context, Cairo.Context cr, double x, double y, double width, double height, Gtk.PositionType gap_side);

8010

[CCode (cheader_filename = "gtk/gtk.h")]

8011

public static void render_focus (Gtk.StyleContext context, Cairo.Context cr, double x, double y, double width, double height);

8012

[CCode (cheader_filename = "gtk/gtk.h")]

8013

public static void render_frame (Gtk.StyleContext context, Cairo.Context cr, double x, double y, double width, double height);

8014

[CCode (cheader_filename = "gtk/gtk.h")]

8015

public static void render_frame_gap (Gtk.StyleContext context, Cairo.Context cr, double x, double y, double width, double height, Gtk.PositionType gap_side, double xy0_gap, double xy1_gap);

8016

[CCode (cheader_filename = "gtk/gtk.h")]

8017

public static void render_handle (Gtk.StyleContext context, Cairo.Context cr, double x, double y, double width, double height);

8018

[CCode (cheader_filename = "gtk/gtk.h")]

8019

public static unowned Gdk.Pixbuf render_icon_pixbuf (Gtk.StyleContext context, Gtk.IconSource source, Gtk.IconSize size);

8020

[CCode (cheader_filename = "gtk/gtk.h")]

8021

public static void render_layout (Gtk.StyleContext context, Cairo.Context cr, double x, double y, Pango.Layout layout);

8022

[CCode (cheader_filename = "gtk/gtk.h")]

8023

public static void render_line (Gtk.StyleContext context, Cairo.Context cr, double x0, double y0, double x1, double y1);

8024

[CCode (cheader_filename = "gtk/gtk.h")]

8025

public static void render_option (Gtk.StyleContext context, Cairo.Context cr, double x, double y, double width, double height);

8026

[CCode (cheader_filename = "gtk/gtk.h")]

8027

public static void render_slider (Gtk.StyleContext context, Cairo.Context cr, double x, double y, double width, double height, Gtk.Orientation orientation);

8028

[CCode (cheader_filename = "gtk/gtk.h")]

7468

8029

public static void rgb_to_hsv (double r, double g, double b, double h, double s, double v);

7469

8030

[CCode (cheader_filename = "gtk/gtk.h")]

7470

8031

public static void selection_add_target (Gtk.Widget widget, Gdk.Atom selection, Gdk.Atom target, uint info);

7483

8044

[CCode (cheader_filename = "gtk/gtk.h")]

7484

8045

public static void set_debug_flags (uint flags);

7485

8046

[CCode (cheader_filename = "gtk/gtk.h")]

7486

public static unowned string set_locale ();

7487

[CCode (cheader_filename = "gtk/gtk.h")]

7488

8047

public static void show_about_dialog (Gtk.Window? parent, ...);

7489

8048

[CCode (cheader_filename = "gtk/gtk.h")]

7490

8049

public static bool show_uri (Gdk.Screen? screen, string uri, uint32 timestamp) throws GLib.Error;

Older »