1 /* 2 * This file is part of gtkD. 3 * 4 * gtkD is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU Lesser General Public License 6 * as published by the Free Software Foundation; either version 3 7 * of the License, or (at your option) any later version, with 8 * some exceptions, please read the COPYING file. 9 * 10 * gtkD is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU Lesser General Public License for more details. 14 * 15 * You should have received a copy of the GNU Lesser General Public License 16 * along with gtkD; if not, write to the Free Software 17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA 18 */ 19 20 // generated automatically - do not change 21 // find conversion definition on APILookup.txt 22 // implement new conversion functionalities on the wrap.utils pakage 23 24 25 module gtk.c.types; 26 27 public import atk.c.types; 28 public import cairo.c.types; 29 public import gdk.c.types; 30 public import gdkpixbuf.c.types; 31 public import gio.c.types; 32 public import glib.c.types; 33 public import gobject.c.types; 34 public import pango.c.types; 35 36 alias GtkAllocation* Allocation; 37 38 /** 39 * A #GtkAllocation-struct of a widget represents region 40 * which has been allocated to the widget by its parent. It is a subregion 41 * of its parents allocation. See 42 * [GtkWidget’s geometry management section][geometry-management] for 43 * more information. 44 */ 45 public alias GdkRectangle GtkAllocation; 46 47 public alias char* GtkStock; 48 49 /** 50 * Accelerator flags used with gtk_accel_group_connect(). 51 */ 52 public enum GtkAccelFlags 53 { 54 /** 55 * Accelerator is visible 56 */ 57 VISIBLE = 1, 58 /** 59 * Accelerator not removable 60 */ 61 LOCKED = 2, 62 /** 63 * Mask 64 */ 65 MASK = 7, 66 } 67 alias GtkAccelFlags AccelFlags; 68 69 /** 70 * Controls how a widget deals with extra space in a single (x or y) 71 * dimension. 72 * 73 * Alignment only matters if the widget receives a “too large” allocation, 74 * for example if you packed the widget with the #GtkWidget:expand 75 * flag inside a #GtkBox, then the widget might get extra space. If 76 * you have for example a 16x16 icon inside a 32x32 space, the icon 77 * could be scaled and stretched, it could be centered, or it could be 78 * positioned to one side of the space. 79 * 80 * Note that in horizontal context @GTK_ALIGN_START and @GTK_ALIGN_END 81 * are interpreted relative to text direction. 82 * 83 * GTK_ALIGN_BASELINE support for it is optional for containers and widgets, and 84 * it is only supported for vertical alignment. When its not supported by 85 * a child or a container it is treated as @GTK_ALIGN_FILL. 86 */ 87 public enum GtkAlign 88 { 89 /** 90 * stretch to fill all space if possible, center if 91 * no meaningful way to stretch 92 */ 93 FILL = 0, 94 /** 95 * snap to left or top side, leaving space on right 96 * or bottom 97 */ 98 START = 1, 99 /** 100 * snap to right or bottom side, leaving space on left 101 * or top 102 */ 103 END = 2, 104 /** 105 * center natural width of widget inside the 106 * allocation 107 */ 108 CENTER = 3, 109 /** 110 * align the widget according to the baseline. Since 3.10. 111 */ 112 BASELINE = 4, 113 } 114 alias GtkAlign Align; 115 116 /** 117 * Types of user actions that may be blocked by gtk_application_inhibit(). 118 * 119 * Since: 3.4 120 */ 121 public enum GtkApplicationInhibitFlags 122 { 123 /** 124 * Inhibit ending the user session 125 * by logging out or by shutting down the computer 126 */ 127 LOGOUT = 1, 128 /** 129 * Inhibit user switching 130 */ 131 SWITCH = 2, 132 /** 133 * Inhibit suspending the 134 * session or computer 135 */ 136 SUSPEND = 4, 137 /** 138 * Inhibit the session being 139 * marked as idle (and possibly locked) 140 */ 141 IDLE = 8, 142 } 143 alias GtkApplicationInhibitFlags ApplicationInhibitFlags; 144 145 /** 146 * Used to specify the placement of scroll arrows in scrolling menus. 147 */ 148 public enum GtkArrowPlacement 149 { 150 /** 151 * Place one arrow on each end of the menu. 152 */ 153 BOTH = 0, 154 /** 155 * Place both arrows at the top of the menu. 156 */ 157 START = 1, 158 /** 159 * Place both arrows at the bottom of the menu. 160 */ 161 END = 2, 162 } 163 alias GtkArrowPlacement ArrowPlacement; 164 165 /** 166 * Used to indicate the direction in which an arrow should point. 167 */ 168 public enum GtkArrowType 169 { 170 /** 171 * Represents an upward pointing arrow. 172 */ 173 UP = 0, 174 /** 175 * Represents a downward pointing arrow. 176 */ 177 DOWN = 1, 178 /** 179 * Represents a left pointing arrow. 180 */ 181 LEFT = 2, 182 /** 183 * Represents a right pointing arrow. 184 */ 185 RIGHT = 3, 186 /** 187 * No arrow. Since 2.10. 188 */ 189 NONE = 4, 190 } 191 alias GtkArrowType ArrowType; 192 193 /** 194 * An enum for determining the page role inside the #GtkAssistant. It's 195 * used to handle buttons sensitivity and visibility. 196 * 197 * Note that an assistant needs to end its page flow with a page of type 198 * %GTK_ASSISTANT_PAGE_CONFIRM, %GTK_ASSISTANT_PAGE_SUMMARY or 199 * %GTK_ASSISTANT_PAGE_PROGRESS to be correct. 200 * 201 * The Cancel button will only be shown if the page isn’t “committed”. 202 * See gtk_assistant_commit() for details. 203 */ 204 public enum GtkAssistantPageType 205 { 206 /** 207 * The page has regular contents. Both the 208 * Back and forward buttons will be shown. 209 */ 210 CONTENT = 0, 211 /** 212 * The page contains an introduction to the 213 * assistant task. Only the Forward button will be shown if there is a 214 * next page. 215 */ 216 INTRO = 1, 217 /** 218 * The page lets the user confirm or deny the 219 * changes. The Back and Apply buttons will be shown. 220 */ 221 CONFIRM = 2, 222 /** 223 * The page informs the user of the changes 224 * done. Only the Close button will be shown. 225 */ 226 SUMMARY = 3, 227 /** 228 * Used for tasks that take a long time to 229 * complete, blocks the assistant until the page is marked as complete. 230 * Only the back button will be shown. 231 */ 232 PROGRESS = 4, 233 /** 234 * Used for when other page types are not 235 * appropriate. No buttons will be shown, and the application must 236 * add its own buttons through gtk_assistant_add_action_widget(). 237 */ 238 CUSTOM = 5, 239 } 240 alias GtkAssistantPageType AssistantPageType; 241 242 /** 243 * Denotes the expansion properties that a widget will have when it (or its 244 * parent) is resized. 245 */ 246 public enum GtkAttachOptions 247 { 248 /** 249 * the widget should expand to take up any extra space in its 250 * container that has been allocated. 251 */ 252 EXPAND = 1, 253 /** 254 * the widget should shrink as and when possible. 255 */ 256 SHRINK = 2, 257 /** 258 * the widget should fill the space allocated to it. 259 */ 260 FILL = 4, 261 } 262 alias GtkAttachOptions AttachOptions; 263 264 /** 265 * Whenever a container has some form of natural row it may align 266 * children in that row along a common typographical baseline. If 267 * the amount of verical space in the row is taller than the total 268 * requested height of the baseline-aligned children then it can use a 269 * #GtkBaselinePosition to select where to put the baseline inside the 270 * extra availible space. 271 * 272 * Since: 3.10 273 */ 274 public enum GtkBaselinePosition 275 { 276 /** 277 * Align the baseline at the top 278 */ 279 TOP = 0, 280 /** 281 * Center the baseline 282 */ 283 CENTER = 1, 284 /** 285 * Align the baseline at the bottom 286 */ 287 BOTTOM = 2, 288 } 289 alias GtkBaselinePosition BaselinePosition; 290 291 /** 292 * Describes how the border of a UI element should be rendered. 293 */ 294 public enum GtkBorderStyle 295 { 296 /** 297 * No visible border 298 */ 299 NONE = 0, 300 /** 301 * A single line segment 302 */ 303 SOLID = 1, 304 /** 305 * Looks as if the content is sunken into the canvas 306 */ 307 INSET = 2, 308 /** 309 * Looks as if the content is coming out of the canvas 310 */ 311 OUTSET = 3, 312 /** 313 * Same as @GTK_BORDER_STYLE_NONE 314 */ 315 HIDDEN = 4, 316 /** 317 * A series of round dots 318 */ 319 DOTTED = 5, 320 /** 321 * A series of square-ended dashes 322 */ 323 DASHED = 6, 324 /** 325 * Two parallel lines with some space between them 326 */ 327 DOUBLE = 7, 328 /** 329 * Looks as if it were carved in the canvas 330 */ 331 GROOVE = 8, 332 /** 333 * Looks as if it were coming out of the canvas 334 */ 335 RIDGE = 9, 336 } 337 alias GtkBorderStyle BorderStyle; 338 339 /** 340 * Error codes that identify various errors that can occur while using 341 * #GtkBuilder. 342 */ 343 public enum GtkBuilderError 344 { 345 /** 346 * A type-func attribute didn’t name 347 * a function that returns a #GType. 348 */ 349 INVALID_TYPE_FUNCTION = 0, 350 /** 351 * The input contained a tag that #GtkBuilder 352 * can’t handle. 353 */ 354 UNHANDLED_TAG = 1, 355 /** 356 * An attribute that is required by 357 * #GtkBuilder was missing. 358 */ 359 MISSING_ATTRIBUTE = 2, 360 /** 361 * #GtkBuilder found an attribute that 362 * it doesn’t understand. 363 */ 364 INVALID_ATTRIBUTE = 3, 365 /** 366 * #GtkBuilder found a tag that 367 * it doesn’t understand. 368 */ 369 INVALID_TAG = 4, 370 /** 371 * A required property value was 372 * missing. 373 */ 374 MISSING_PROPERTY_VALUE = 5, 375 /** 376 * #GtkBuilder couldn’t parse 377 * some attribute value. 378 */ 379 INVALID_VALUE = 6, 380 /** 381 * The input file requires a newer version 382 * of GTK+. 383 */ 384 VERSION_MISMATCH = 7, 385 /** 386 * An object id occurred twice. 387 */ 388 DUPLICATE_ID = 8, 389 /** 390 * A specified object type is of the same type or 391 * derived from the type of the composite class being extended with builder XML. 392 */ 393 OBJECT_TYPE_REFUSED = 9, 394 /** 395 * The wrong type was specified in a composite class’s template XML 396 */ 397 TEMPLATE_MISMATCH = 10, 398 /** 399 * The specified property is unknown for the object class. 400 */ 401 INVALID_PROPERTY = 11, 402 /** 403 * The specified signal is unknown for the object class. 404 */ 405 INVALID_SIGNAL = 12, 406 /** 407 * An object id is unknown 408 */ 409 INVALID_ID = 13, 410 } 411 alias GtkBuilderError BuilderError; 412 413 /** 414 * Used to dictate the style that a #GtkButtonBox uses to layout the buttons it 415 * contains. 416 */ 417 public enum GtkButtonBoxStyle 418 { 419 /** 420 * Buttons are evenly spread across the box. 421 */ 422 SPREAD = 1, 423 /** 424 * Buttons are placed at the edges of the box. 425 */ 426 EDGE = 2, 427 /** 428 * Buttons are grouped towards the start of the box, 429 * (on the left for a HBox, or the top for a VBox). 430 */ 431 START = 3, 432 /** 433 * Buttons are grouped towards the end of the box, 434 * (on the right for a HBox, or the bottom for a VBox). 435 */ 436 END = 4, 437 /** 438 * Buttons are centered in the box. Since 2.12. 439 */ 440 CENTER = 5, 441 /** 442 * Buttons expand to fill the box. This entails giving 443 * buttons a "linked" appearance, making button sizes homogeneous, and 444 * setting spacing to 0 (same as calling gtk_box_set_homogeneous() and 445 * gtk_box_set_spacing() manually). Since 3.12. 446 */ 447 EXPAND = 6, 448 } 449 alias GtkButtonBoxStyle ButtonBoxStyle; 450 451 /** 452 * The role specifies the desired appearance of a #GtkModelButton. 453 */ 454 public enum GtkButtonRole 455 { 456 /** 457 * A plain button 458 */ 459 NORMAL = 0, 460 /** 461 * A check button 462 */ 463 CHECK = 1, 464 /** 465 * A radio button 466 */ 467 RADIO = 2, 468 } 469 alias GtkButtonRole ButtonRole; 470 471 /** 472 * Prebuilt sets of buttons for the dialog. If 473 * none of these choices are appropriate, simply use %GTK_BUTTONS_NONE 474 * then call gtk_dialog_add_buttons(). 475 * 476 * > Please note that %GTK_BUTTONS_OK, %GTK_BUTTONS_YES_NO 477 * > and %GTK_BUTTONS_OK_CANCEL are discouraged by the 478 * > [GNOME Human Interface Guidelines](http://library.gnome.org/devel/hig-book/stable/). 479 */ 480 public enum GtkButtonsType 481 { 482 /** 483 * no buttons at all 484 */ 485 NONE = 0, 486 /** 487 * an OK button 488 */ 489 OK = 1, 490 /** 491 * a Close button 492 */ 493 CLOSE = 2, 494 /** 495 * a Cancel button 496 */ 497 CANCEL = 3, 498 /** 499 * Yes and No buttons 500 */ 501 YES_NO = 4, 502 /** 503 * OK and Cancel buttons 504 */ 505 OK_CANCEL = 5, 506 } 507 alias GtkButtonsType ButtonsType; 508 509 /** 510 * These options can be used to influence the display and behaviour of a #GtkCalendar. 511 */ 512 public enum GtkCalendarDisplayOptions 513 { 514 /** 515 * Specifies that the month and year should be displayed. 516 */ 517 SHOW_HEADING = 1, 518 /** 519 * Specifies that three letter day descriptions should be present. 520 */ 521 SHOW_DAY_NAMES = 2, 522 /** 523 * Prevents the user from switching months with the calendar. 524 */ 525 NO_MONTH_CHANGE = 4, 526 /** 527 * Displays each week numbers of the current year, down the 528 * left side of the calendar. 529 */ 530 SHOW_WEEK_NUMBERS = 8, 531 /** 532 * Just show an indicator, not the full details 533 * text when details are provided. See gtk_calendar_set_detail_func(). 534 */ 535 SHOW_DETAILS = 32, 536 } 537 alias GtkCalendarDisplayOptions CalendarDisplayOptions; 538 539 /** 540 * Determines if the edited accelerators are GTK+ accelerators. If 541 * they are, consumed modifiers are suppressed, only accelerators 542 * accepted by GTK+ are allowed, and the accelerators are rendered 543 * in the same way as they are in menus. 544 */ 545 public enum GtkCellRendererAccelMode 546 { 547 /** 548 * GTK+ accelerators mode 549 */ 550 GTK = 0, 551 /** 552 * Other accelerator mode 553 */ 554 OTHER = 1, 555 } 556 alias GtkCellRendererAccelMode CellRendererAccelMode; 557 558 /** 559 * Identifies how the user can interact with a particular cell. 560 */ 561 public enum GtkCellRendererMode 562 { 563 /** 564 * The cell is just for display 565 * and cannot be interacted with. Note that this doesn’t mean that eg. the 566 * row being drawn can’t be selected -- just that a particular element of 567 * it cannot be individually modified. 568 */ 569 INERT = 0, 570 /** 571 * The cell can be clicked. 572 */ 573 ACTIVATABLE = 1, 574 /** 575 * The cell can be edited or otherwise modified. 576 */ 577 EDITABLE = 2, 578 } 579 alias GtkCellRendererMode CellRendererMode; 580 581 /** 582 * Tells how a cell is to be rendered. 583 */ 584 public enum GtkCellRendererState 585 { 586 /** 587 * The cell is currently selected, and 588 * probably has a selection colored background to render to. 589 */ 590 SELECTED = 1, 591 /** 592 * The mouse is hovering over the cell. 593 */ 594 PRELIT = 2, 595 /** 596 * The cell is drawn in an insensitive manner 597 */ 598 INSENSITIVE = 4, 599 /** 600 * The cell is in a sorted row 601 */ 602 SORTED = 8, 603 /** 604 * The cell is in the focus row. 605 */ 606 FOCUSED = 16, 607 /** 608 * The cell is in a row that can be expanded. Since 3.4 609 */ 610 EXPANDABLE = 32, 611 /** 612 * The cell is in a row that is expanded. Since 3.4 613 */ 614 EXPANDED = 64, 615 } 616 alias GtkCellRendererState CellRendererState; 617 618 /** 619 * Specifies which corner a child widget should be placed in when packed into 620 * a #GtkScrolledWindow. This is effectively the opposite of where the scroll 621 * bars are placed. 622 */ 623 public enum GtkCornerType 624 { 625 /** 626 * Place the scrollbars on the right and bottom of the 627 * widget (default behaviour). 628 */ 629 TOP_LEFT = 0, 630 /** 631 * Place the scrollbars on the top and right of the 632 * widget. 633 */ 634 BOTTOM_LEFT = 1, 635 /** 636 * Place the scrollbars on the left and bottom of the 637 * widget. 638 */ 639 TOP_RIGHT = 2, 640 /** 641 * Place the scrollbars on the top and left of the 642 * widget. 643 */ 644 BOTTOM_RIGHT = 3, 645 } 646 alias GtkCornerType CornerType; 647 648 /** 649 * Error codes for %GTK_CSS_PROVIDER_ERROR. 650 */ 651 public enum GtkCssProviderError 652 { 653 /** 654 * Failed. 655 */ 656 FAILED = 0, 657 /** 658 * Syntax error. 659 */ 660 SYNTAX = 1, 661 /** 662 * Import error. 663 */ 664 IMPORT = 2, 665 /** 666 * Name error. 667 */ 668 NAME = 3, 669 /** 670 * Deprecation error. 671 */ 672 DEPRECATED = 4, 673 /** 674 * Unknown value. 675 */ 676 UNKNOWN_VALUE = 5, 677 } 678 alias GtkCssProviderError CssProviderError; 679 680 /** 681 * The different types of sections indicate parts of a CSS document as 682 * parsed by GTK’s CSS parser. They are oriented towards the 683 * [CSS Grammar](http://www.w3.org/TR/CSS21/grammar.html), 684 * but may contain extensions. 685 * 686 * More types might be added in the future as the parser incorporates 687 * more features. 688 * 689 * Since: 3.2 690 */ 691 public enum GtkCssSectionType 692 { 693 /** 694 * The section describes a complete document. 695 * This section time is the only one where gtk_css_section_get_parent() 696 * might return %NULL. 697 */ 698 DOCUMENT = 0, 699 /** 700 * The section defines an import rule. 701 */ 702 IMPORT = 1, 703 /** 704 * The section defines a color. This 705 * is a GTK extension to CSS. 706 */ 707 COLOR_DEFINITION = 2, 708 /** 709 * The section defines a binding set. This 710 * is a GTK extension to CSS. 711 */ 712 BINDING_SET = 3, 713 /** 714 * The section defines a CSS ruleset. 715 */ 716 RULESET = 4, 717 /** 718 * The section defines a CSS selector. 719 */ 720 SELECTOR = 5, 721 /** 722 * The section defines the declaration of 723 * a CSS variable. 724 */ 725 DECLARATION = 6, 726 /** 727 * The section defines the value of a CSS declaration. 728 */ 729 VALUE = 7, 730 /** 731 * The section defines keyframes. See [CSS 732 * Animations](http://dev.w3.org/csswg/css3-animations/#keyframes) for details. Since 3.6 733 */ 734 KEYFRAMES = 8, 735 } 736 alias GtkCssSectionType CssSectionType; 737 738 public enum GtkDebugFlag 739 { 740 MISC = 1, 741 PLUGSOCKET = 2, 742 TEXT = 4, 743 TREE = 8, 744 UPDATES = 16, 745 KEYBINDINGS = 32, 746 MULTIHEAD = 64, 747 MODULES = 128, 748 GEOMETRY = 256, 749 ICONTHEME = 512, 750 PRINTING = 1024, 751 BUILDER = 2048, 752 SIZE_REQUEST = 4096, 753 NO_CSS_CACHE = 8192, 754 BASELINES = 16384, 755 PIXEL_CACHE = 32768, 756 NO_PIXEL_CACHE = 65536, 757 INTERACTIVE = 131072, 758 TOUCHSCREEN = 262144, 759 ACTIONS = 524288, 760 RESIZE = 1048576, 761 LAYOUT = 2097152, 762 } 763 alias GtkDebugFlag DebugFlag; 764 765 /** 766 * See also: #GtkEntry::delete-from-cursor. 767 */ 768 public enum GtkDeleteType 769 { 770 /** 771 * Delete characters. 772 */ 773 CHARS = 0, 774 /** 775 * Delete only the portion of the word to the 776 * left/right of cursor if we’re in the middle of a word. 777 */ 778 WORD_ENDS = 1, 779 /** 780 * Delete words. 781 */ 782 WORDS = 2, 783 /** 784 * Delete display-lines. Display-lines 785 * refers to the visible lines, with respect to to the current line 786 * breaks. As opposed to paragraphs, which are defined by line 787 * breaks in the input. 788 */ 789 DISPLAY_LINES = 3, 790 /** 791 * Delete only the portion of the 792 * display-line to the left/right of cursor. 793 */ 794 DISPLAY_LINE_ENDS = 4, 795 /** 796 * Delete to the end of the 797 * paragraph. Like C-k in Emacs (or its reverse). 798 */ 799 PARAGRAPH_ENDS = 5, 800 /** 801 * Delete entire line. Like C-k in pico. 802 */ 803 PARAGRAPHS = 6, 804 /** 805 * Delete only whitespace. Like M-\ in Emacs. 806 */ 807 WHITESPACE = 7, 808 } 809 alias GtkDeleteType DeleteType; 810 811 /** 812 * The #GtkDestDefaults enumeration specifies the various 813 * types of action that will be taken on behalf 814 * of the user for a drag destination site. 815 */ 816 public enum GtkDestDefaults 817 { 818 /** 819 * If set for a widget, GTK+, during a drag over this 820 * widget will check if the drag matches this widget’s list of possible targets 821 * and actions. 822 * GTK+ will then call gdk_drag_status() as appropriate. 823 */ 824 MOTION = 1, 825 /** 826 * If set for a widget, GTK+ will draw a highlight on 827 * this widget as long as a drag is over this widget and the widget drag format 828 * and action are acceptable. 829 */ 830 HIGHLIGHT = 2, 831 /** 832 * If set for a widget, when a drop occurs, GTK+ will 833 * will check if the drag matches this widget’s list of possible targets and 834 * actions. If so, GTK+ will call gtk_drag_get_data() on behalf of the widget. 835 * Whether or not the drop is successful, GTK+ will call gtk_drag_finish(). If 836 * the action was a move, then if the drag was successful, then %TRUE will be 837 * passed for the @delete parameter to gtk_drag_finish(). 838 */ 839 DROP = 4, 840 /** 841 * If set, specifies that all default actions should 842 * be taken. 843 */ 844 ALL = 7, 845 } 846 alias GtkDestDefaults DestDefaults; 847 848 /** 849 * Flags used to influence dialog construction. 850 */ 851 public enum GtkDialogFlags 852 { 853 /** 854 * Make the constructed dialog modal, 855 * see gtk_window_set_modal() 856 */ 857 MODAL = 1, 858 /** 859 * Destroy the dialog when its 860 * parent is destroyed, see gtk_window_set_destroy_with_parent() 861 */ 862 DESTROY_WITH_PARENT = 2, 863 /** 864 * Create dialog with actions in header 865 * bar instead of action area. Since 3.12. 866 */ 867 USE_HEADER_BAR = 4, 868 } 869 alias GtkDialogFlags DialogFlags; 870 871 /** 872 * Focus movement types. 873 */ 874 public enum GtkDirectionType 875 { 876 /** 877 * Move forward. 878 */ 879 TAB_FORWARD = 0, 880 /** 881 * Move backward. 882 */ 883 TAB_BACKWARD = 1, 884 /** 885 * Move up. 886 */ 887 UP = 2, 888 /** 889 * Move down. 890 */ 891 DOWN = 3, 892 /** 893 * Move left. 894 */ 895 LEFT = 4, 896 /** 897 * Move right. 898 */ 899 RIGHT = 5, 900 } 901 alias GtkDirectionType DirectionType; 902 903 /** 904 * Gives an indication why a drag operation failed. 905 * The value can by obtained by connecting to the 906 * #GtkWidget::drag-failed signal. 907 */ 908 public enum GtkDragResult 909 { 910 /** 911 * The drag operation was successful. 912 */ 913 SUCCESS = 0, 914 /** 915 * No suitable drag target. 916 */ 917 NO_TARGET = 1, 918 /** 919 * The user cancelled the drag operation. 920 */ 921 USER_CANCELLED = 2, 922 /** 923 * The drag operation timed out. 924 */ 925 TIMEOUT_EXPIRED = 3, 926 /** 927 * The pointer or keyboard grab used 928 * for the drag operation was broken. 929 */ 930 GRAB_BROKEN = 4, 931 /** 932 * The drag operation failed due to some 933 * unspecified error. 934 */ 935 ERROR = 5, 936 } 937 alias GtkDragResult DragResult; 938 939 /** 940 * Specifies the side of the entry at which an icon is placed. 941 * 942 * Since: 2.16 943 */ 944 public enum GtkEntryIconPosition 945 { 946 /** 947 * At the beginning of the entry (depending on the text direction). 948 */ 949 PRIMARY = 0, 950 /** 951 * At the end of the entry (depending on the text direction). 952 */ 953 SECONDARY = 1, 954 } 955 alias GtkEntryIconPosition EntryIconPosition; 956 957 /** 958 * Describes the state of a #GdkEventSequence in a #GtkGesture. 959 * 960 * Since: 3.14 961 */ 962 public enum GtkEventSequenceState 963 { 964 /** 965 * The sequence is handled, but not grabbed. 966 */ 967 NONE = 0, 968 /** 969 * The sequence is handled and grabbed. 970 */ 971 CLAIMED = 1, 972 /** 973 * The sequence is denied. 974 */ 975 DENIED = 2, 976 } 977 alias GtkEventSequenceState EventSequenceState; 978 979 /** 980 * Used to specify the style of the expanders drawn by a #GtkTreeView. 981 */ 982 public enum GtkExpanderStyle 983 { 984 /** 985 * The style used for a collapsed subtree. 986 */ 987 COLLAPSED = 0, 988 /** 989 * Intermediate style used during animation. 990 */ 991 SEMI_COLLAPSED = 1, 992 /** 993 * Intermediate style used during animation. 994 */ 995 SEMI_EXPANDED = 2, 996 /** 997 * The style used for an expanded subtree. 998 */ 999 EXPANDED = 3, 1000 } 1001 alias GtkExpanderStyle ExpanderStyle; 1002 1003 /** 1004 * Describes whether a #GtkFileChooser is being used to open existing files 1005 * or to save to a possibly new file. 1006 */ 1007 public enum GtkFileChooserAction 1008 { 1009 /** 1010 * Indicates open mode. The file chooser 1011 * will only let the user pick an existing file. 1012 */ 1013 OPEN = 0, 1014 /** 1015 * Indicates save mode. The file chooser 1016 * will let the user pick an existing file, or type in a new 1017 * filename. 1018 */ 1019 SAVE = 1, 1020 /** 1021 * Indicates an Open mode for 1022 * selecting folders. The file chooser will let the user pick an 1023 * existing folder. 1024 */ 1025 SELECT_FOLDER = 2, 1026 /** 1027 * Indicates a mode for creating a 1028 * new folder. The file chooser will let the user name an existing or 1029 * new folder. 1030 */ 1031 CREATE_FOLDER = 3, 1032 } 1033 alias GtkFileChooserAction FileChooserAction; 1034 1035 /** 1036 * Used as a return value of handlers for the 1037 * #GtkFileChooser::confirm-overwrite signal of a #GtkFileChooser. This 1038 * value determines whether the file chooser will present the stock 1039 * confirmation dialog, accept the user’s choice of a filename, or 1040 * let the user choose another filename. 1041 * 1042 * Since: 2.8 1043 */ 1044 public enum GtkFileChooserConfirmation 1045 { 1046 /** 1047 * The file chooser will present 1048 * its stock dialog to confirm about overwriting an existing file. 1049 */ 1050 CONFIRM = 0, 1051 /** 1052 * The file chooser will 1053 * terminate and accept the user’s choice of a file name. 1054 */ 1055 ACCEPT_FILENAME = 1, 1056 /** 1057 * The file chooser will 1058 * continue running, so as to let the user select another file name. 1059 */ 1060 SELECT_AGAIN = 2, 1061 } 1062 alias GtkFileChooserConfirmation FileChooserConfirmation; 1063 1064 /** 1065 * These identify the various errors that can occur while calling 1066 * #GtkFileChooser functions. 1067 */ 1068 public enum GtkFileChooserError 1069 { 1070 /** 1071 * Indicates that a file does not exist. 1072 */ 1073 NONEXISTENT = 0, 1074 /** 1075 * Indicates a malformed filename. 1076 */ 1077 BAD_FILENAME = 1, 1078 /** 1079 * Indicates a duplicate path (e.g. when 1080 * adding a bookmark). 1081 */ 1082 ALREADY_EXISTS = 2, 1083 /** 1084 * Indicates an incomplete hostname (e.g. "http://foo" without a slash after that). 1085 */ 1086 INCOMPLETE_HOSTNAME = 3, 1087 } 1088 alias GtkFileChooserError FileChooserError; 1089 1090 /** 1091 * These flags indicate what parts of a #GtkFileFilterInfo struct 1092 * are filled or need to be filled. 1093 */ 1094 public enum GtkFileFilterFlags 1095 { 1096 /** 1097 * the filename of the file being tested 1098 */ 1099 FILENAME = 1, 1100 /** 1101 * the URI for the file being tested 1102 */ 1103 URI = 2, 1104 /** 1105 * the string that will be used to 1106 * display the file in the file chooser 1107 */ 1108 DISPLAY_NAME = 4, 1109 /** 1110 * the mime type of the file 1111 */ 1112 MIME_TYPE = 8, 1113 } 1114 alias GtkFileFilterFlags FileFilterFlags; 1115 1116 /** 1117 * Style for input method preedit. See also 1118 * #GtkSettings:gtk-im-preedit-style 1119 */ 1120 public enum GtkIMPreeditStyle 1121 { 1122 /** 1123 * Deprecated 1124 */ 1125 NOTHING = 0, 1126 /** 1127 * Deprecated 1128 */ 1129 CALLBACK = 1, 1130 /** 1131 * Deprecated 1132 */ 1133 NONE = 2, 1134 } 1135 alias GtkIMPreeditStyle IMPreeditStyle; 1136 1137 /** 1138 * Style for input method status. See also 1139 * #GtkSettings:gtk-im-status-style 1140 */ 1141 public enum GtkIMStatusStyle 1142 { 1143 /** 1144 * Deprecated 1145 */ 1146 NOTHING = 0, 1147 /** 1148 * Deprecated 1149 */ 1150 CALLBACK = 1, 1151 /** 1152 * Deprecated 1153 */ 1154 NONE = 2, 1155 } 1156 alias GtkIMStatusStyle IMStatusStyle; 1157 1158 /** 1159 * Used to specify options for gtk_icon_theme_lookup_icon() 1160 */ 1161 public enum GtkIconLookupFlags 1162 { 1163 /** 1164 * Never get SVG icons, even if gdk-pixbuf 1165 * supports them. Cannot be used together with %GTK_ICON_LOOKUP_FORCE_SVG. 1166 */ 1167 NO_SVG = 1, 1168 /** 1169 * Get SVG icons, even if gdk-pixbuf 1170 * doesn’t support them. 1171 * Cannot be used together with %GTK_ICON_LOOKUP_NO_SVG. 1172 */ 1173 FORCE_SVG = 2, 1174 /** 1175 * When passed to 1176 * gtk_icon_theme_lookup_icon() includes builtin icons 1177 * as well as files. For a builtin icon, gtk_icon_info_get_filename() 1178 * is %NULL and you need to call gtk_icon_info_get_builtin_pixbuf(). 1179 */ 1180 USE_BUILTIN = 4, 1181 /** 1182 * Try to shorten icon name at '-' 1183 * characters before looking at inherited themes. This flag is only 1184 * supported in functions that take a single icon name. For more general 1185 * fallback, see gtk_icon_theme_choose_icon(). Since 2.12. 1186 */ 1187 GENERIC_FALLBACK = 8, 1188 /** 1189 * Always get the icon scaled to the 1190 * requested size. Since 2.14. 1191 */ 1192 FORCE_SIZE = 16, 1193 /** 1194 * Try to always load regular icons, even 1195 * when symbolic icon names are given. Since 3.14. 1196 */ 1197 FORCE_REGULAR = 32, 1198 /** 1199 * Try to always load symbolic icons, even 1200 * when regular icon names are given. Since 3.14. 1201 */ 1202 FORCE_SYMBOLIC = 64, 1203 /** 1204 * Try to load a variant of the icon for left-to-right 1205 * text direction. Since 3.14. 1206 */ 1207 DIR_LTR = 128, 1208 /** 1209 * Try to load a variant of the icon for right-to-left 1210 * text direction. Since 3.14. 1211 */ 1212 DIR_RTL = 256, 1213 } 1214 alias GtkIconLookupFlags IconLookupFlags; 1215 1216 /** 1217 * Built-in stock icon sizes. 1218 */ 1219 public enum GtkIconSize 1220 { 1221 /** 1222 * Invalid size. 1223 */ 1224 INVALID = 0, 1225 /** 1226 * Size appropriate for menus (16px). 1227 */ 1228 MENU = 1, 1229 /** 1230 * Size appropriate for small toolbars (16px). 1231 */ 1232 SMALL_TOOLBAR = 2, 1233 /** 1234 * Size appropriate for large toolbars (24px) 1235 */ 1236 LARGE_TOOLBAR = 3, 1237 /** 1238 * Size appropriate for buttons (16px) 1239 */ 1240 BUTTON = 4, 1241 /** 1242 * Size appropriate for drag and drop (32px) 1243 */ 1244 DND = 5, 1245 /** 1246 * Size appropriate for dialogs (48px) 1247 */ 1248 DIALOG = 6, 1249 } 1250 alias GtkIconSize IconSize; 1251 1252 /** 1253 * Error codes for GtkIconTheme operations. 1254 */ 1255 public enum GtkIconThemeError 1256 { 1257 /** 1258 * The icon specified does not exist in the theme 1259 */ 1260 NOT_FOUND = 0, 1261 /** 1262 * An unspecified error occurred. 1263 */ 1264 FAILED = 1, 1265 } 1266 alias GtkIconThemeError IconThemeError; 1267 1268 /** 1269 * An enum for determining where a dropped item goes. 1270 */ 1271 public enum GtkIconViewDropPosition 1272 { 1273 /** 1274 * no drop possible 1275 */ 1276 NO_DROP = 0, 1277 /** 1278 * dropped item replaces the item 1279 */ 1280 DROP_INTO = 1, 1281 /** 1282 * droppped item is inserted to the left 1283 */ 1284 DROP_LEFT = 2, 1285 /** 1286 * dropped item is inserted to the right 1287 */ 1288 DROP_RIGHT = 3, 1289 /** 1290 * dropped item is inserted above 1291 */ 1292 DROP_ABOVE = 4, 1293 /** 1294 * dropped item is inserted below 1295 */ 1296 DROP_BELOW = 5, 1297 } 1298 alias GtkIconViewDropPosition IconViewDropPosition; 1299 1300 /** 1301 * Describes the image data representation used by a #GtkImage. If you 1302 * want to get the image from the widget, you can only get the 1303 * currently-stored representation. e.g. if the 1304 * gtk_image_get_storage_type() returns #GTK_IMAGE_PIXBUF, then you can 1305 * call gtk_image_get_pixbuf() but not gtk_image_get_stock(). For empty 1306 * images, you can request any storage type (call any of the "get" 1307 * functions), but they will all return %NULL values. 1308 */ 1309 public enum GtkImageType 1310 { 1311 /** 1312 * there is no image displayed by the widget 1313 */ 1314 EMPTY = 0, 1315 /** 1316 * the widget contains a #GdkPixbuf 1317 */ 1318 PIXBUF = 1, 1319 /** 1320 * the widget contains a [stock item name][gtkstock] 1321 */ 1322 STOCK = 2, 1323 /** 1324 * the widget contains a #GtkIconSet 1325 */ 1326 ICON_SET = 3, 1327 /** 1328 * the widget contains a #GdkPixbufAnimation 1329 */ 1330 ANIMATION = 4, 1331 /** 1332 * the widget contains a named icon. 1333 * This image type was added in GTK+ 2.6 1334 */ 1335 ICON_NAME = 5, 1336 /** 1337 * the widget contains a #GIcon. 1338 * This image type was added in GTK+ 2.14 1339 */ 1340 GICON = 6, 1341 /** 1342 * the widget contains a #cairo_surface_t. 1343 * This image type was added in GTK+ 3.10 1344 */ 1345 SURFACE = 7, 1346 } 1347 alias GtkImageType ImageType; 1348 1349 /** 1350 * Describes hints that might be taken into account by input methods 1351 * or applications. Note that input methods may already tailor their 1352 * behaviour according to the #GtkInputPurpose of the entry. 1353 * 1354 * Some common sense is expected when using these flags - mixing 1355 * @GTK_INPUT_HINT_LOWERCASE with any of the uppercase hints makes no sense. 1356 * 1357 * This enumeration may be extended in the future; input methods should 1358 * ignore unknown values. 1359 * 1360 * Since: 3.6 1361 */ 1362 public enum GtkInputHints 1363 { 1364 /** 1365 * No special behaviour suggested 1366 */ 1367 NONE = 0, 1368 /** 1369 * Suggest checking for typos 1370 */ 1371 SPELLCHECK = 1, 1372 /** 1373 * Suggest not checking for typos 1374 */ 1375 NO_SPELLCHECK = 2, 1376 /** 1377 * Suggest word completion 1378 */ 1379 WORD_COMPLETION = 4, 1380 /** 1381 * Suggest to convert all text to lowercase 1382 */ 1383 LOWERCASE = 8, 1384 /** 1385 * Suggest to capitalize all text 1386 */ 1387 UPPERCASE_CHARS = 16, 1388 /** 1389 * Suggest to capitalize the first 1390 * character of each word 1391 */ 1392 UPPERCASE_WORDS = 32, 1393 /** 1394 * Suggest to capitalize the 1395 * first word of each sentence 1396 */ 1397 UPPERCASE_SENTENCES = 64, 1398 /** 1399 * Suggest to not show an onscreen keyboard 1400 * (e.g for a calculator that already has all the keys). 1401 */ 1402 INHIBIT_OSK = 128, 1403 /** 1404 * The text is vertical. Since 3.18 1405 */ 1406 VERTICAL_WRITING = 256, 1407 /** 1408 * Suggest offering Emoji support. Since 3.22.20 1409 */ 1410 EMOJI = 512, 1411 /** 1412 * Suggest not offering Emoji support. Since 3.22.20 1413 */ 1414 NO_EMOJI = 1024, 1415 } 1416 alias GtkInputHints InputHints; 1417 1418 /** 1419 * Describes primary purpose of the input widget. This information is 1420 * useful for on-screen keyboards and similar input methods to decide 1421 * which keys should be presented to the user. 1422 * 1423 * Note that the purpose is not meant to impose a totally strict rule 1424 * about allowed characters, and does not replace input validation. 1425 * It is fine for an on-screen keyboard to let the user override the 1426 * character set restriction that is expressed by the purpose. The 1427 * application is expected to validate the entry contents, even if 1428 * it specified a purpose. 1429 * 1430 * The difference between @GTK_INPUT_PURPOSE_DIGITS and 1431 * @GTK_INPUT_PURPOSE_NUMBER is that the former accepts only digits 1432 * while the latter also some punctuation (like commas or points, plus, 1433 * minus) and “e” or “E” as in 3.14E+000. 1434 * 1435 * This enumeration may be extended in the future; input methods should 1436 * interpret unknown values as “free form”. 1437 * 1438 * Since: 3.6 1439 */ 1440 public enum GtkInputPurpose 1441 { 1442 /** 1443 * Allow any character 1444 */ 1445 FREE_FORM = 0, 1446 /** 1447 * Allow only alphabetic characters 1448 */ 1449 ALPHA = 1, 1450 /** 1451 * Allow only digits 1452 */ 1453 DIGITS = 2, 1454 /** 1455 * Edited field expects numbers 1456 */ 1457 NUMBER = 3, 1458 /** 1459 * Edited field expects phone number 1460 */ 1461 PHONE = 4, 1462 /** 1463 * Edited field expects URL 1464 */ 1465 URL = 5, 1466 /** 1467 * Edited field expects email address 1468 */ 1469 EMAIL = 6, 1470 /** 1471 * Edited field expects the name of a person 1472 */ 1473 NAME = 7, 1474 /** 1475 * Like @GTK_INPUT_PURPOSE_FREE_FORM, but characters are hidden 1476 */ 1477 PASSWORD = 8, 1478 /** 1479 * Like @GTK_INPUT_PURPOSE_DIGITS, but characters are hidden 1480 */ 1481 PIN = 9, 1482 } 1483 alias GtkInputPurpose InputPurpose; 1484 1485 /** 1486 * Describes how a rendered element connects to adjacent elements. 1487 */ 1488 public enum GtkJunctionSides 1489 { 1490 /** 1491 * No junctions. 1492 */ 1493 NONE = 0, 1494 /** 1495 * Element connects on the top-left corner. 1496 */ 1497 CORNER_TOPLEFT = 1, 1498 /** 1499 * Element connects on the top-right corner. 1500 */ 1501 CORNER_TOPRIGHT = 2, 1502 /** 1503 * Element connects on the bottom-left corner. 1504 */ 1505 CORNER_BOTTOMLEFT = 4, 1506 /** 1507 * Element connects on the bottom-right corner. 1508 */ 1509 CORNER_BOTTOMRIGHT = 8, 1510 /** 1511 * Element connects on the top side. 1512 */ 1513 TOP = 3, 1514 /** 1515 * Element connects on the bottom side. 1516 */ 1517 BOTTOM = 12, 1518 /** 1519 * Element connects on the left side. 1520 */ 1521 LEFT = 5, 1522 /** 1523 * Element connects on the right side. 1524 */ 1525 RIGHT = 10, 1526 } 1527 alias GtkJunctionSides JunctionSides; 1528 1529 /** 1530 * Used for justifying the text inside a #GtkLabel widget. (See also 1531 * #GtkAlignment). 1532 */ 1533 public enum GtkJustification 1534 { 1535 /** 1536 * The text is placed at the left edge of the label. 1537 */ 1538 LEFT = 0, 1539 /** 1540 * The text is placed at the right edge of the label. 1541 */ 1542 RIGHT = 1, 1543 /** 1544 * The text is placed in the center of the label. 1545 */ 1546 CENTER = 2, 1547 /** 1548 * The text is placed is distributed across the label. 1549 */ 1550 FILL = 3, 1551 } 1552 alias GtkJustification Justification; 1553 1554 /** 1555 * Describes how #GtkLevelBar contents should be rendered. 1556 * Note that this enumeration could be extended with additional modes 1557 * in the future. 1558 * 1559 * Since: 3.6 1560 */ 1561 public enum GtkLevelBarMode 1562 { 1563 /** 1564 * the bar has a continuous mode 1565 */ 1566 CONTINUOUS = 0, 1567 /** 1568 * the bar has a discrete mode 1569 */ 1570 DISCRETE = 1, 1571 } 1572 alias GtkLevelBarMode LevelBarMode; 1573 1574 /** 1575 * The type of license for an application. 1576 * 1577 * This enumeration can be expanded at later date. 1578 * 1579 * Since: 3.0 1580 */ 1581 public enum GtkLicense 1582 { 1583 /** 1584 * No license specified 1585 */ 1586 UNKNOWN = 0, 1587 /** 1588 * A license text is going to be specified by the 1589 * developer 1590 */ 1591 CUSTOM = 1, 1592 /** 1593 * The GNU General Public License, version 2.0 or later 1594 */ 1595 GPL_2_0 = 2, 1596 /** 1597 * The GNU General Public License, version 3.0 or later 1598 */ 1599 GPL_3_0 = 3, 1600 /** 1601 * The GNU Lesser General Public License, version 2.1 or later 1602 */ 1603 LGPL_2_1 = 4, 1604 /** 1605 * The GNU Lesser General Public License, version 3.0 or later 1606 */ 1607 LGPL_3_0 = 5, 1608 /** 1609 * The BSD standard license 1610 */ 1611 BSD = 6, 1612 /** 1613 * The MIT/X11 standard license 1614 */ 1615 MIT_X11 = 7, 1616 /** 1617 * The Artistic License, version 2.0 1618 */ 1619 ARTISTIC = 8, 1620 /** 1621 * The GNU General Public License, version 2.0 only. Since 3.12. 1622 */ 1623 GPL_2_0_ONLY = 9, 1624 /** 1625 * The GNU General Public License, version 3.0 only. Since 3.12. 1626 */ 1627 GPL_3_0_ONLY = 10, 1628 /** 1629 * The GNU Lesser General Public License, version 2.1 only. Since 3.12. 1630 */ 1631 LGPL_2_1_ONLY = 11, 1632 /** 1633 * The GNU Lesser General Public License, version 3.0 only. Since 3.12. 1634 */ 1635 LGPL_3_0_ONLY = 12, 1636 /** 1637 * The GNU Affero General Public License, version 3.0 or later. Since: 3.22. 1638 */ 1639 AGPL_3_0 = 13, 1640 } 1641 alias GtkLicense License; 1642 1643 /** 1644 * An enumeration representing directional movements within a menu. 1645 */ 1646 public enum GtkMenuDirectionType 1647 { 1648 /** 1649 * To the parent menu shell 1650 */ 1651 PARENT = 0, 1652 /** 1653 * To the submenu, if any, associated with the item 1654 */ 1655 CHILD = 1, 1656 /** 1657 * To the next menu item 1658 */ 1659 NEXT = 2, 1660 /** 1661 * To the previous menu item 1662 */ 1663 PREV = 3, 1664 } 1665 alias GtkMenuDirectionType MenuDirectionType; 1666 1667 /** 1668 * The type of message being displayed in the dialog. 1669 */ 1670 public enum GtkMessageType : uint 1671 { 1672 /** 1673 * Informational message 1674 */ 1675 INFO = 0, 1676 /** 1677 * Non-fatal warning message 1678 */ 1679 WARNING = 1, 1680 /** 1681 * Question requiring a choice 1682 */ 1683 QUESTION = 2, 1684 /** 1685 * Fatal error message 1686 */ 1687 ERROR = 3, 1688 /** 1689 * None of the above 1690 */ 1691 OTHER = 4, 1692 } 1693 alias GtkMessageType MessageType; 1694 1695 public enum GtkMovementStep 1696 { 1697 /** 1698 * Move forward or back by graphemes 1699 */ 1700 LOGICAL_POSITIONS = 0, 1701 /** 1702 * Move left or right by graphemes 1703 */ 1704 VISUAL_POSITIONS = 1, 1705 /** 1706 * Move forward or back by words 1707 */ 1708 WORDS = 2, 1709 /** 1710 * Move up or down lines (wrapped lines) 1711 */ 1712 DISPLAY_LINES = 3, 1713 /** 1714 * Move to either end of a line 1715 */ 1716 DISPLAY_LINE_ENDS = 4, 1717 /** 1718 * Move up or down paragraphs (newline-ended lines) 1719 */ 1720 PARAGRAPHS = 5, 1721 /** 1722 * Move to either end of a paragraph 1723 */ 1724 PARAGRAPH_ENDS = 6, 1725 /** 1726 * Move by pages 1727 */ 1728 PAGES = 7, 1729 /** 1730 * Move to ends of the buffer 1731 */ 1732 BUFFER_ENDS = 8, 1733 /** 1734 * Move horizontally by pages 1735 */ 1736 HORIZONTAL_PAGES = 9, 1737 } 1738 alias GtkMovementStep MovementStep; 1739 1740 public enum GtkNotebookTab 1741 { 1742 FIRST = 0, 1743 LAST = 1, 1744 } 1745 alias GtkNotebookTab NotebookTab; 1746 1747 /** 1748 * Used to determine the layout of pages on a sheet when printing 1749 * multiple pages per sheet. 1750 */ 1751 public enum GtkNumberUpLayout 1752 { 1753 /** 1754 * ![](layout-lrtb.png) 1755 */ 1756 LRTB = 0, 1757 /** 1758 * ![](layout-lrbt.png) 1759 */ 1760 LRBT = 1, 1761 /** 1762 * ![](layout-rltb.png) 1763 */ 1764 RLTB = 2, 1765 /** 1766 * ![](layout-rlbt.png) 1767 */ 1768 RLBT = 3, 1769 /** 1770 * ![](layout-tblr.png) 1771 */ 1772 TBLR = 4, 1773 /** 1774 * ![](layout-tbrl.png) 1775 */ 1776 TBRL = 5, 1777 /** 1778 * ![](layout-btlr.png) 1779 */ 1780 BTLR = 6, 1781 /** 1782 * ![](layout-btrl.png) 1783 */ 1784 BTRL = 7, 1785 } 1786 alias GtkNumberUpLayout NumberUpLayout; 1787 1788 /** 1789 * Represents the orientation of widgets and other objects which can be switched 1790 * between horizontal and vertical orientation on the fly, like #GtkToolbar or 1791 * #GtkGesturePan. 1792 */ 1793 public enum GtkOrientation 1794 { 1795 /** 1796 * The element is in horizontal orientation. 1797 */ 1798 HORIZONTAL = 0, 1799 /** 1800 * The element is in vertical orientation. 1801 */ 1802 VERTICAL = 1, 1803 } 1804 alias GtkOrientation Orientation; 1805 1806 /** 1807 * Determines how widgets should be packed inside menubars 1808 * and menuitems contained in menubars. 1809 */ 1810 public enum GtkPackDirection 1811 { 1812 /** 1813 * Widgets are packed left-to-right 1814 */ 1815 LTR = 0, 1816 /** 1817 * Widgets are packed right-to-left 1818 */ 1819 RTL = 1, 1820 /** 1821 * Widgets are packed top-to-bottom 1822 */ 1823 TTB = 2, 1824 /** 1825 * Widgets are packed bottom-to-top 1826 */ 1827 BTT = 3, 1828 } 1829 alias GtkPackDirection PackDirection; 1830 1831 /** 1832 * Represents the packing location #GtkBox children. (See: #GtkVBox, 1833 * #GtkHBox, and #GtkButtonBox). 1834 */ 1835 public enum GtkPackType 1836 { 1837 /** 1838 * The child is packed into the start of the box 1839 */ 1840 START = 0, 1841 /** 1842 * The child is packed into the end of the box 1843 */ 1844 END = 1, 1845 } 1846 alias GtkPackType PackType; 1847 1848 /** 1849 * The type of a pad action. 1850 */ 1851 public enum GtkPadActionType 1852 { 1853 /** 1854 * Action is triggered by a pad button 1855 */ 1856 BUTTON = 0, 1857 /** 1858 * Action is triggered by a pad ring 1859 */ 1860 RING = 1, 1861 /** 1862 * Action is triggered by a pad strip 1863 */ 1864 STRIP = 2, 1865 } 1866 alias GtkPadActionType PadActionType; 1867 1868 /** 1869 * See also gtk_print_settings_set_orientation(). 1870 */ 1871 public enum GtkPageOrientation 1872 { 1873 /** 1874 * Portrait mode. 1875 */ 1876 PORTRAIT = 0, 1877 /** 1878 * Landscape mode. 1879 */ 1880 LANDSCAPE = 1, 1881 /** 1882 * Reverse portrait mode. 1883 */ 1884 REVERSE_PORTRAIT = 2, 1885 /** 1886 * Reverse landscape mode. 1887 */ 1888 REVERSE_LANDSCAPE = 3, 1889 } 1890 alias GtkPageOrientation PageOrientation; 1891 1892 /** 1893 * See also gtk_print_job_set_page_set(). 1894 */ 1895 public enum GtkPageSet 1896 { 1897 /** 1898 * All pages. 1899 */ 1900 ALL = 0, 1901 /** 1902 * Even pages. 1903 */ 1904 EVEN = 1, 1905 /** 1906 * Odd pages. 1907 */ 1908 ODD = 2, 1909 } 1910 alias GtkPageSet PageSet; 1911 1912 /** 1913 * Describes the panning direction of a #GtkGesturePan 1914 * 1915 * Since: 3.14 1916 */ 1917 public enum GtkPanDirection 1918 { 1919 /** 1920 * panned towards the left 1921 */ 1922 LEFT = 0, 1923 /** 1924 * panned towards the right 1925 */ 1926 RIGHT = 1, 1927 /** 1928 * panned upwards 1929 */ 1930 UP = 2, 1931 /** 1932 * panned downwards 1933 */ 1934 DOWN = 3, 1935 } 1936 alias GtkPanDirection PanDirection; 1937 1938 /** 1939 * Priorities for path lookups. 1940 * See also gtk_binding_set_add_path(). 1941 */ 1942 public enum GtkPathPriorityType 1943 { 1944 /** 1945 * Deprecated 1946 */ 1947 LOWEST = 0, 1948 /** 1949 * Deprecated 1950 */ 1951 GTK = 4, 1952 /** 1953 * Deprecated 1954 */ 1955 APPLICATION = 8, 1956 /** 1957 * Deprecated 1958 */ 1959 THEME = 10, 1960 /** 1961 * Deprecated 1962 */ 1963 RC = 12, 1964 /** 1965 * Deprecated 1966 */ 1967 HIGHEST = 15, 1968 } 1969 alias GtkPathPriorityType PathPriorityType; 1970 1971 /** 1972 * Widget path types. 1973 * See also gtk_binding_set_add_path(). 1974 */ 1975 public enum GtkPathType 1976 { 1977 /** 1978 * Deprecated 1979 */ 1980 WIDGET = 0, 1981 /** 1982 * Deprecated 1983 */ 1984 WIDGET_CLASS = 1, 1985 /** 1986 * Deprecated 1987 */ 1988 CLASS = 2, 1989 } 1990 alias GtkPathType PathType; 1991 1992 /** 1993 * These flags serve two purposes. First, the application can call gtk_places_sidebar_set_open_flags() 1994 * using these flags as a bitmask. This tells the sidebar that the application is able to open 1995 * folders selected from the sidebar in various ways, for example, in new tabs or in new windows in 1996 * addition to the normal mode. 1997 * 1998 * Second, when one of these values gets passed back to the application in the 1999 * #GtkPlacesSidebar::open-location signal, it means that the application should 2000 * open the selected location in the normal way, in a new tab, or in a new 2001 * window. The sidebar takes care of determining the desired way to open the location, 2002 * based on the modifier keys that the user is pressing at the time the selection is made. 2003 * 2004 * If the application never calls gtk_places_sidebar_set_open_flags(), then the sidebar will only 2005 * use #GTK_PLACES_OPEN_NORMAL in the #GtkPlacesSidebar::open-location signal. This is the 2006 * default mode of operation. 2007 */ 2008 public enum GtkPlacesOpenFlags 2009 { 2010 /** 2011 * This is the default mode that #GtkPlacesSidebar uses if no other flags 2012 * are specified. It indicates that the calling application should open the selected location 2013 * in the normal way, for example, in the folder view beside the sidebar. 2014 */ 2015 NORMAL = 1, 2016 /** 2017 * When passed to gtk_places_sidebar_set_open_flags(), this indicates 2018 * that the application can open folders selected from the sidebar in new tabs. This value 2019 * will be passed to the #GtkPlacesSidebar::open-location signal when the user selects 2020 * that a location be opened in a new tab instead of in the standard fashion. 2021 */ 2022 NEW_TAB = 2, 2023 /** 2024 * Similar to @GTK_PLACES_OPEN_NEW_TAB, but indicates that the application 2025 * can open folders in new windows. 2026 */ 2027 NEW_WINDOW = 4, 2028 } 2029 alias GtkPlacesOpenFlags PlacesOpenFlags; 2030 2031 /** 2032 * Determines how the size should be computed to achieve the one of the 2033 * visibility mode for the scrollbars. 2034 */ 2035 public enum GtkPolicyType 2036 { 2037 /** 2038 * The scrollbar is always visible. The view size is 2039 * independent of the content. 2040 */ 2041 ALWAYS = 0, 2042 /** 2043 * The scrollbar will appear and disappear as necessary. 2044 * For example, when all of a #GtkTreeView can not be seen. 2045 */ 2046 AUTOMATIC = 1, 2047 /** 2048 * The scrollbar should never appear. In this mode the 2049 * content determines the size. 2050 */ 2051 NEVER = 2, 2052 /** 2053 * Don't show a scrollbar, but don't force the 2054 * size to follow the content. This can be used e.g. to make multiple 2055 * scrolled windows share a scrollbar. Since: 3.16 2056 */ 2057 EXTERNAL = 3, 2058 } 2059 alias GtkPolicyType PolicyType; 2060 2061 /** 2062 * Describes constraints to positioning of popovers. More values 2063 * may be added to this enumeration in the future. 2064 * 2065 * Since: 3.20 2066 */ 2067 public enum GtkPopoverConstraint 2068 { 2069 /** 2070 * Don't constrain the popover position 2071 * beyond what is imposed by the implementation 2072 */ 2073 NONE = 0, 2074 /** 2075 * Constrain the popover to the boundaries 2076 * of the window that it is attached to 2077 */ 2078 WINDOW = 1, 2079 } 2080 alias GtkPopoverConstraint PopoverConstraint; 2081 2082 /** 2083 * Describes which edge of a widget a certain feature is positioned at, e.g. the 2084 * tabs of a #GtkNotebook, the handle of a #GtkHandleBox or the label of a 2085 * #GtkScale. 2086 */ 2087 public enum GtkPositionType 2088 { 2089 /** 2090 * The feature is at the left edge. 2091 */ 2092 LEFT = 0, 2093 /** 2094 * The feature is at the right edge. 2095 */ 2096 RIGHT = 1, 2097 /** 2098 * The feature is at the top edge. 2099 */ 2100 TOP = 2, 2101 /** 2102 * The feature is at the bottom edge. 2103 */ 2104 BOTTOM = 3, 2105 } 2106 alias GtkPositionType PositionType; 2107 2108 /** 2109 * See also gtk_print_settings_set_duplex(). 2110 */ 2111 public enum GtkPrintDuplex 2112 { 2113 /** 2114 * No duplex. 2115 */ 2116 SIMPLEX = 0, 2117 /** 2118 * Horizontal duplex. 2119 */ 2120 HORIZONTAL = 1, 2121 /** 2122 * Vertical duplex. 2123 */ 2124 VERTICAL = 2, 2125 } 2126 alias GtkPrintDuplex PrintDuplex; 2127 2128 /** 2129 * Error codes that identify various errors that can occur while 2130 * using the GTK+ printing support. 2131 */ 2132 public enum GtkPrintError 2133 { 2134 /** 2135 * An unspecified error occurred. 2136 */ 2137 GENERAL = 0, 2138 /** 2139 * An internal error occurred. 2140 */ 2141 INTERNAL_ERROR = 1, 2142 /** 2143 * A memory allocation failed. 2144 */ 2145 NOMEM = 2, 2146 /** 2147 * An error occurred while loading a page setup 2148 * or paper size from a key file. 2149 */ 2150 INVALID_FILE = 3, 2151 } 2152 alias GtkPrintError PrintError; 2153 2154 /** 2155 * The @action parameter to gtk_print_operation_run() 2156 * determines what action the print operation should perform. 2157 */ 2158 public enum GtkPrintOperationAction 2159 { 2160 /** 2161 * Show the print dialog. 2162 */ 2163 PRINT_DIALOG = 0, 2164 /** 2165 * Start to print without showing 2166 * the print dialog, based on the current print settings. 2167 */ 2168 PRINT = 1, 2169 /** 2170 * Show the print preview. 2171 */ 2172 PREVIEW = 2, 2173 /** 2174 * Export to a file. This requires 2175 * the export-filename property to be set. 2176 */ 2177 EXPORT = 3, 2178 } 2179 alias GtkPrintOperationAction PrintOperationAction; 2180 2181 /** 2182 * A value of this type is returned by gtk_print_operation_run(). 2183 */ 2184 public enum GtkPrintOperationResult 2185 { 2186 /** 2187 * An error has occurred. 2188 */ 2189 ERROR = 0, 2190 /** 2191 * The print settings should be stored. 2192 */ 2193 APPLY = 1, 2194 /** 2195 * The print operation has been canceled, 2196 * the print settings should not be stored. 2197 */ 2198 CANCEL = 2, 2199 /** 2200 * The print operation is not complete 2201 * yet. This value will only be returned when running asynchronously. 2202 */ 2203 IN_PROGRESS = 3, 2204 } 2205 alias GtkPrintOperationResult PrintOperationResult; 2206 2207 /** 2208 * See also gtk_print_job_set_pages() 2209 */ 2210 public enum GtkPrintPages 2211 { 2212 /** 2213 * All pages. 2214 */ 2215 ALL = 0, 2216 /** 2217 * Current page. 2218 */ 2219 CURRENT = 1, 2220 /** 2221 * Range of pages. 2222 */ 2223 RANGES = 2, 2224 /** 2225 * Selected pages. 2226 */ 2227 SELECTION = 3, 2228 } 2229 alias GtkPrintPages PrintPages; 2230 2231 /** 2232 * See also gtk_print_settings_set_quality(). 2233 */ 2234 public enum GtkPrintQuality 2235 { 2236 /** 2237 * Low quality. 2238 */ 2239 LOW = 0, 2240 /** 2241 * Normal quality. 2242 */ 2243 NORMAL = 1, 2244 /** 2245 * High quality. 2246 */ 2247 HIGH = 2, 2248 /** 2249 * Draft quality. 2250 */ 2251 DRAFT = 3, 2252 } 2253 alias GtkPrintQuality PrintQuality; 2254 2255 /** 2256 * The status gives a rough indication of the completion of a running 2257 * print operation. 2258 */ 2259 public enum GtkPrintStatus 2260 { 2261 /** 2262 * The printing has not started yet; this 2263 * status is set initially, and while the print dialog is shown. 2264 */ 2265 INITIAL = 0, 2266 /** 2267 * This status is set while the begin-print 2268 * signal is emitted and during pagination. 2269 */ 2270 PREPARING = 1, 2271 /** 2272 * This status is set while the 2273 * pages are being rendered. 2274 */ 2275 GENERATING_DATA = 2, 2276 /** 2277 * The print job is being sent off to the 2278 * printer. 2279 */ 2280 SENDING_DATA = 3, 2281 /** 2282 * The print job has been sent to the printer, 2283 * but is not printed for some reason, e.g. the printer may be stopped. 2284 */ 2285 PENDING = 4, 2286 /** 2287 * Some problem has occurred during 2288 * printing, e.g. a paper jam. 2289 */ 2290 PENDING_ISSUE = 5, 2291 /** 2292 * The printer is processing the print job. 2293 */ 2294 PRINTING = 6, 2295 /** 2296 * The printing has been completed successfully. 2297 */ 2298 FINISHED = 7, 2299 /** 2300 * The printing has been aborted. 2301 */ 2302 FINISHED_ABORTED = 8, 2303 } 2304 alias GtkPrintStatus PrintStatus; 2305 2306 /** 2307 * Describes the stage at which events are fed into a #GtkEventController. 2308 * 2309 * Since: 3.14 2310 */ 2311 public enum GtkPropagationPhase 2312 { 2313 /** 2314 * Events are not delivered automatically. Those can be 2315 * manually fed through gtk_event_controller_handle_event(). This should 2316 * only be used when full control about when, or whether the controller 2317 * handles the event is needed. 2318 */ 2319 NONE = 0, 2320 /** 2321 * Events are delivered in the capture phase. The 2322 * capture phase happens before the bubble phase, runs from the toplevel down 2323 * to the event widget. This option should only be used on containers that 2324 * might possibly handle events before their children do. 2325 */ 2326 CAPTURE = 1, 2327 /** 2328 * Events are delivered in the bubble phase. The bubble 2329 * phase happens after the capture phase, and before the default handlers 2330 * are run. This phase runs from the event widget, up to the toplevel. 2331 */ 2332 BUBBLE = 2, 2333 /** 2334 * Events are delivered in the default widget event handlers, 2335 * note that widget implementations must chain up on button, motion, touch and 2336 * grab broken handlers for controllers in this phase to be run. 2337 */ 2338 TARGET = 3, 2339 } 2340 alias GtkPropagationPhase PropagationPhase; 2341 2342 /** 2343 * Deprecated 2344 */ 2345 public enum GtkRcFlags 2346 { 2347 /** 2348 * Deprecated 2349 */ 2350 FG = 1, 2351 /** 2352 * Deprecated 2353 */ 2354 BG = 2, 2355 /** 2356 * Deprecated 2357 */ 2358 TEXT = 4, 2359 /** 2360 * Deprecated 2361 */ 2362 BASE = 8, 2363 } 2364 alias GtkRcFlags RcFlags; 2365 2366 /** 2367 * The #GtkRcTokenType enumeration represents the tokens 2368 * in the RC file. It is exposed so that theme engines 2369 * can reuse these tokens when parsing the theme-engine 2370 * specific portions of a RC file. 2371 * 2372 * Deprecated: Use #GtkCssProvider instead. 2373 */ 2374 public enum GtkRcTokenType 2375 { 2376 /** 2377 * Deprecated 2378 */ 2379 INVALID = 270, 2380 /** 2381 * Deprecated 2382 */ 2383 INCLUDE = 271, 2384 /** 2385 * Deprecated 2386 */ 2387 NORMAL = 272, 2388 /** 2389 * Deprecated 2390 */ 2391 ACTIVE = 273, 2392 /** 2393 * Deprecated 2394 */ 2395 PRELIGHT = 274, 2396 /** 2397 * Deprecated 2398 */ 2399 SELECTED = 275, 2400 /** 2401 * Deprecated 2402 */ 2403 INSENSITIVE = 276, 2404 /** 2405 * Deprecated 2406 */ 2407 FG = 277, 2408 /** 2409 * Deprecated 2410 */ 2411 BG = 278, 2412 /** 2413 * Deprecated 2414 */ 2415 TEXT = 279, 2416 /** 2417 * Deprecated 2418 */ 2419 BASE = 280, 2420 /** 2421 * Deprecated 2422 */ 2423 XTHICKNESS = 281, 2424 /** 2425 * Deprecated 2426 */ 2427 YTHICKNESS = 282, 2428 /** 2429 * Deprecated 2430 */ 2431 FONT = 283, 2432 /** 2433 * Deprecated 2434 */ 2435 FONTSET = 284, 2436 /** 2437 * Deprecated 2438 */ 2439 FONT_NAME = 285, 2440 /** 2441 * Deprecated 2442 */ 2443 BG_PIXMAP = 286, 2444 /** 2445 * Deprecated 2446 */ 2447 PIXMAP_PATH = 287, 2448 /** 2449 * Deprecated 2450 */ 2451 STYLE = 288, 2452 /** 2453 * Deprecated 2454 */ 2455 BINDING = 289, 2456 /** 2457 * Deprecated 2458 */ 2459 BIND = 290, 2460 /** 2461 * Deprecated 2462 */ 2463 WIDGET = 291, 2464 /** 2465 * Deprecated 2466 */ 2467 WIDGET_CLASS = 292, 2468 /** 2469 * Deprecated 2470 */ 2471 CLASS = 293, 2472 /** 2473 * Deprecated 2474 */ 2475 LOWEST = 294, 2476 /** 2477 * Deprecated 2478 */ 2479 GTK = 295, 2480 /** 2481 * Deprecated 2482 */ 2483 APPLICATION = 296, 2484 /** 2485 * Deprecated 2486 */ 2487 THEME = 297, 2488 /** 2489 * Deprecated 2490 */ 2491 RC = 298, 2492 /** 2493 * Deprecated 2494 */ 2495 HIGHEST = 299, 2496 /** 2497 * Deprecated 2498 */ 2499 ENGINE = 300, 2500 /** 2501 * Deprecated 2502 */ 2503 MODULE_PATH = 301, 2504 /** 2505 * Deprecated 2506 */ 2507 IM_MODULE_PATH = 302, 2508 /** 2509 * Deprecated 2510 */ 2511 IM_MODULE_FILE = 303, 2512 /** 2513 * Deprecated 2514 */ 2515 STOCK = 304, 2516 /** 2517 * Deprecated 2518 */ 2519 LTR = 305, 2520 /** 2521 * Deprecated 2522 */ 2523 RTL = 306, 2524 /** 2525 * Deprecated 2526 */ 2527 COLOR = 307, 2528 /** 2529 * Deprecated 2530 */ 2531 UNBIND = 308, 2532 /** 2533 * Deprecated 2534 */ 2535 LAST = 309, 2536 } 2537 alias GtkRcTokenType RcTokenType; 2538 2539 /** 2540 * These identify the various errors that can occur while calling 2541 * #GtkRecentChooser functions. 2542 * 2543 * Since: 2.10 2544 */ 2545 public enum GtkRecentChooserError 2546 { 2547 /** 2548 * Indicates that a file does not exist 2549 */ 2550 NOT_FOUND = 0, 2551 /** 2552 * Indicates a malformed URI 2553 */ 2554 INVALID_URI = 1, 2555 } 2556 alias GtkRecentChooserError RecentChooserError; 2557 2558 /** 2559 * These flags indicate what parts of a #GtkRecentFilterInfo struct 2560 * are filled or need to be filled. 2561 */ 2562 public enum GtkRecentFilterFlags 2563 { 2564 /** 2565 * the URI of the file being tested 2566 */ 2567 URI = 1, 2568 /** 2569 * the string that will be used to 2570 * display the file in the recent chooser 2571 */ 2572 DISPLAY_NAME = 2, 2573 /** 2574 * the mime type of the file 2575 */ 2576 MIME_TYPE = 4, 2577 /** 2578 * the list of applications that have 2579 * registered the file 2580 */ 2581 APPLICATION = 8, 2582 /** 2583 * the groups to which the file belongs to 2584 */ 2585 GROUP = 16, 2586 /** 2587 * the number of days elapsed since the file 2588 * has been registered 2589 */ 2590 AGE = 32, 2591 } 2592 alias GtkRecentFilterFlags RecentFilterFlags; 2593 2594 /** 2595 * Error codes for #GtkRecentManager operations 2596 * 2597 * Since: 2.10 2598 */ 2599 public enum GtkRecentManagerError 2600 { 2601 /** 2602 * the URI specified does not exists in 2603 * the recently used resources list. 2604 */ 2605 NOT_FOUND = 0, 2606 /** 2607 * the URI specified is not valid. 2608 */ 2609 INVALID_URI = 1, 2610 /** 2611 * the supplied string is not 2612 * UTF-8 encoded. 2613 */ 2614 INVALID_ENCODING = 2, 2615 /** 2616 * no application has registered 2617 * the specified item. 2618 */ 2619 NOT_REGISTERED = 3, 2620 /** 2621 * failure while reading the recently used 2622 * resources file. 2623 */ 2624 READ = 4, 2625 /** 2626 * failure while writing the recently used 2627 * resources file. 2628 */ 2629 WRITE = 5, 2630 /** 2631 * unspecified error. 2632 */ 2633 UNKNOWN = 6, 2634 } 2635 alias GtkRecentManagerError RecentManagerError; 2636 2637 /** 2638 * Used to specify the sorting method to be applyed to the recently 2639 * used resource list. 2640 * 2641 * Since: 2.10 2642 */ 2643 public enum GtkRecentSortType 2644 { 2645 /** 2646 * Do not sort the returned list of recently used 2647 * resources. 2648 */ 2649 NONE = 0, 2650 /** 2651 * Sort the returned list with the most recently used 2652 * items first. 2653 */ 2654 MRU = 1, 2655 /** 2656 * Sort the returned list with the least recently used 2657 * items first. 2658 */ 2659 LRU = 2, 2660 /** 2661 * Sort the returned list using a custom sorting 2662 * function passed using gtk_recent_chooser_set_sort_func(). 2663 */ 2664 CUSTOM = 3, 2665 } 2666 alias GtkRecentSortType RecentSortType; 2667 2668 /** 2669 * Describes a region within a widget. 2670 */ 2671 public enum GtkRegionFlags 2672 { 2673 /** 2674 * Region has an even number within a set. 2675 */ 2676 EVEN = 1, 2677 /** 2678 * Region has an odd number within a set. 2679 */ 2680 ODD = 2, 2681 /** 2682 * Region is the first one within a set. 2683 */ 2684 FIRST = 4, 2685 /** 2686 * Region is the last one within a set. 2687 */ 2688 LAST = 8, 2689 /** 2690 * Region is the only one within a set. 2691 */ 2692 ONLY = 16, 2693 /** 2694 * Region is part of a sorted area. 2695 */ 2696 SORTED = 32, 2697 } 2698 alias GtkRegionFlags RegionFlags; 2699 2700 /** 2701 * Indicated the relief to be drawn around a #GtkButton. 2702 */ 2703 public enum GtkReliefStyle 2704 { 2705 /** 2706 * Draw a normal relief. 2707 */ 2708 NORMAL = 0, 2709 /** 2710 * A half relief. Deprecated in 3.14, does the same as @GTK_RELIEF_NORMAL 2711 */ 2712 HALF = 1, 2713 /** 2714 * No relief. 2715 */ 2716 NONE = 2, 2717 } 2718 alias GtkReliefStyle ReliefStyle; 2719 2720 public enum GtkResizeMode 2721 { 2722 /** 2723 * Pass resize request to the parent 2724 */ 2725 PARENT = 0, 2726 /** 2727 * Queue resizes on this widget 2728 */ 2729 QUEUE = 1, 2730 /** 2731 * Resize immediately. Deprecated. 2732 */ 2733 IMMEDIATE = 2, 2734 } 2735 alias GtkResizeMode ResizeMode; 2736 2737 /** 2738 * Predefined values for use as response ids in gtk_dialog_add_button(). 2739 * All predefined values are negative, GTK+ leaves positive values for 2740 * application-defined response ids. 2741 */ 2742 public enum GtkResponseType 2743 { 2744 /** 2745 * Returned if an action widget has no response id, 2746 * or if the dialog gets programmatically hidden or destroyed 2747 */ 2748 NONE = -1, 2749 /** 2750 * Generic response id, not used by GTK+ dialogs 2751 */ 2752 REJECT = -2, 2753 /** 2754 * Generic response id, not used by GTK+ dialogs 2755 */ 2756 ACCEPT = -3, 2757 /** 2758 * Returned if the dialog is deleted 2759 */ 2760 DELETE_EVENT = -4, 2761 /** 2762 * Returned by OK buttons in GTK+ dialogs 2763 */ 2764 OK = -5, 2765 /** 2766 * Returned by Cancel buttons in GTK+ dialogs 2767 */ 2768 CANCEL = -6, 2769 /** 2770 * Returned by Close buttons in GTK+ dialogs 2771 */ 2772 CLOSE = -7, 2773 /** 2774 * Returned by Yes buttons in GTK+ dialogs 2775 */ 2776 YES = -8, 2777 /** 2778 * Returned by No buttons in GTK+ dialogs 2779 */ 2780 NO = -9, 2781 /** 2782 * Returned by Apply buttons in GTK+ dialogs 2783 */ 2784 APPLY = -10, 2785 /** 2786 * Returned by Help buttons in GTK+ dialogs 2787 */ 2788 HELP = -11, 2789 } 2790 alias GtkResponseType ResponseType; 2791 2792 /** 2793 * These enumeration values describe the possible transitions 2794 * when the child of a #GtkRevealer widget is shown or hidden. 2795 */ 2796 public enum GtkRevealerTransitionType 2797 { 2798 /** 2799 * No transition 2800 */ 2801 NONE = 0, 2802 /** 2803 * Fade in 2804 */ 2805 CROSSFADE = 1, 2806 /** 2807 * Slide in from the left 2808 */ 2809 SLIDE_RIGHT = 2, 2810 /** 2811 * Slide in from the right 2812 */ 2813 SLIDE_LEFT = 3, 2814 /** 2815 * Slide in from the bottom 2816 */ 2817 SLIDE_UP = 4, 2818 /** 2819 * Slide in from the top 2820 */ 2821 SLIDE_DOWN = 5, 2822 } 2823 alias GtkRevealerTransitionType RevealerTransitionType; 2824 2825 public enum GtkScrollStep 2826 { 2827 /** 2828 * Scroll in steps. 2829 */ 2830 STEPS = 0, 2831 /** 2832 * Scroll by pages. 2833 */ 2834 PAGES = 1, 2835 /** 2836 * Scroll to ends. 2837 */ 2838 ENDS = 2, 2839 /** 2840 * Scroll in horizontal steps. 2841 */ 2842 HORIZONTAL_STEPS = 3, 2843 /** 2844 * Scroll by horizontal pages. 2845 */ 2846 HORIZONTAL_PAGES = 4, 2847 /** 2848 * Scroll to the horizontal ends. 2849 */ 2850 HORIZONTAL_ENDS = 5, 2851 } 2852 alias GtkScrollStep ScrollStep; 2853 2854 /** 2855 * Scrolling types. 2856 */ 2857 public enum GtkScrollType 2858 { 2859 /** 2860 * No scrolling. 2861 */ 2862 NONE = 0, 2863 /** 2864 * Jump to new location. 2865 */ 2866 JUMP = 1, 2867 /** 2868 * Step backward. 2869 */ 2870 STEP_BACKWARD = 2, 2871 /** 2872 * Step forward. 2873 */ 2874 STEP_FORWARD = 3, 2875 /** 2876 * Page backward. 2877 */ 2878 PAGE_BACKWARD = 4, 2879 /** 2880 * Page forward. 2881 */ 2882 PAGE_FORWARD = 5, 2883 /** 2884 * Step up. 2885 */ 2886 STEP_UP = 6, 2887 /** 2888 * Step down. 2889 */ 2890 STEP_DOWN = 7, 2891 /** 2892 * Page up. 2893 */ 2894 PAGE_UP = 8, 2895 /** 2896 * Page down. 2897 */ 2898 PAGE_DOWN = 9, 2899 /** 2900 * Step to the left. 2901 */ 2902 STEP_LEFT = 10, 2903 /** 2904 * Step to the right. 2905 */ 2906 STEP_RIGHT = 11, 2907 /** 2908 * Page to the left. 2909 */ 2910 PAGE_LEFT = 12, 2911 /** 2912 * Page to the right. 2913 */ 2914 PAGE_RIGHT = 13, 2915 /** 2916 * Scroll to start. 2917 */ 2918 START = 14, 2919 /** 2920 * Scroll to end. 2921 */ 2922 END = 15, 2923 } 2924 alias GtkScrollType ScrollType; 2925 2926 /** 2927 * Defines the policy to be used in a scrollable widget when updating 2928 * the scrolled window adjustments in a given orientation. 2929 */ 2930 public enum GtkScrollablePolicy 2931 { 2932 /** 2933 * Scrollable adjustments are based on the minimum size 2934 */ 2935 MINIMUM = 0, 2936 /** 2937 * Scrollable adjustments are based on the natural size 2938 */ 2939 NATURAL = 1, 2940 } 2941 alias GtkScrollablePolicy ScrollablePolicy; 2942 2943 /** 2944 * Used to control what selections users are allowed to make. 2945 */ 2946 public enum GtkSelectionMode 2947 { 2948 /** 2949 * No selection is possible. 2950 */ 2951 NONE = 0, 2952 /** 2953 * Zero or one element may be selected. 2954 */ 2955 SINGLE = 1, 2956 /** 2957 * Exactly one element is selected. 2958 * In some circumstances, such as initially or during a search 2959 * operation, it’s possible for no element to be selected with 2960 * %GTK_SELECTION_BROWSE. What is really enforced is that the user 2961 * can’t deselect a currently selected element except by selecting 2962 * another element. 2963 */ 2964 BROWSE = 2, 2965 /** 2966 * Any number of elements may be selected. 2967 * The Ctrl key may be used to enlarge the selection, and Shift 2968 * key to select between the focus and the child pointed to. 2969 * Some widgets may also allow Click-drag to select a range of elements. 2970 */ 2971 MULTIPLE = 3, 2972 } 2973 alias GtkSelectionMode SelectionMode; 2974 2975 /** 2976 * Determines how GTK+ handles the sensitivity of stepper arrows 2977 * at the end of range widgets. 2978 */ 2979 public enum GtkSensitivityType 2980 { 2981 /** 2982 * The arrow is made insensitive if the 2983 * thumb is at the end 2984 */ 2985 AUTO = 0, 2986 /** 2987 * The arrow is always sensitive 2988 */ 2989 ON = 1, 2990 /** 2991 * The arrow is always insensitive 2992 */ 2993 OFF = 2, 2994 } 2995 alias GtkSensitivityType SensitivityType; 2996 2997 /** 2998 * Used to change the appearance of an outline typically provided by a #GtkFrame. 2999 * 3000 * Note that many themes do not differentiate the appearance of the 3001 * various shadow types: Either their is no visible shadow (@GTK_SHADOW_NONE), 3002 * or there is (any other value). 3003 */ 3004 public enum GtkShadowType 3005 { 3006 /** 3007 * No outline. 3008 */ 3009 NONE = 0, 3010 /** 3011 * The outline is bevelled inwards. 3012 */ 3013 IN = 1, 3014 /** 3015 * The outline is bevelled outwards like a button. 3016 */ 3017 OUT = 2, 3018 /** 3019 * The outline has a sunken 3d appearance. 3020 */ 3021 ETCHED_IN = 3, 3022 /** 3023 * The outline has a raised 3d appearance. 3024 */ 3025 ETCHED_OUT = 4, 3026 } 3027 alias GtkShadowType ShadowType; 3028 3029 /** 3030 * GtkShortcutType specifies the kind of shortcut that is being described. 3031 * More values may be added to this enumeration over time. 3032 * 3033 * Since: 3.20 3034 */ 3035 public enum GtkShortcutType 3036 { 3037 /** 3038 * The shortcut is a keyboard accelerator. The #GtkShortcutsShortcut:accelerator 3039 * property will be used. 3040 */ 3041 ACCELERATOR = 0, 3042 /** 3043 * The shortcut is a pinch gesture. GTK+ provides an icon and subtitle. 3044 */ 3045 GESTURE_PINCH = 1, 3046 /** 3047 * The shortcut is a stretch gesture. GTK+ provides an icon and subtitle. 3048 */ 3049 GESTURE_STRETCH = 2, 3050 /** 3051 * The shortcut is a clockwise rotation gesture. GTK+ provides an icon and subtitle. 3052 */ 3053 GESTURE_ROTATE_CLOCKWISE = 3, 3054 /** 3055 * The shortcut is a counterclockwise rotation gesture. GTK+ provides an icon and subtitle. 3056 */ 3057 GESTURE_ROTATE_COUNTERCLOCKWISE = 4, 3058 /** 3059 * The shortcut is a two-finger swipe gesture. GTK+ provides an icon and subtitle. 3060 */ 3061 GESTURE_TWO_FINGER_SWIPE_LEFT = 5, 3062 /** 3063 * The shortcut is a two-finger swipe gesture. GTK+ provides an icon and subtitle. 3064 */ 3065 GESTURE_TWO_FINGER_SWIPE_RIGHT = 6, 3066 /** 3067 * The shortcut is a gesture. The #GtkShortcutsShortcut:icon property will be 3068 * used. 3069 */ 3070 GESTURE = 7, 3071 } 3072 alias GtkShortcutType ShortcutType; 3073 3074 /** 3075 * The mode of the size group determines the directions in which the size 3076 * group affects the requested sizes of its component widgets. 3077 */ 3078 public enum GtkSizeGroupMode 3079 { 3080 /** 3081 * group has no effect 3082 */ 3083 NONE = 0, 3084 /** 3085 * group affects horizontal requisition 3086 */ 3087 HORIZONTAL = 1, 3088 /** 3089 * group affects vertical requisition 3090 */ 3091 VERTICAL = 2, 3092 /** 3093 * group affects both horizontal and vertical requisition 3094 */ 3095 BOTH = 3, 3096 } 3097 alias GtkSizeGroupMode SizeGroupMode; 3098 3099 /** 3100 * Specifies a preference for height-for-width or 3101 * width-for-height geometry management. 3102 */ 3103 public enum GtkSizeRequestMode 3104 { 3105 /** 3106 * Prefer height-for-width geometry management 3107 */ 3108 HEIGHT_FOR_WIDTH = 0, 3109 /** 3110 * Prefer width-for-height geometry management 3111 */ 3112 WIDTH_FOR_HEIGHT = 1, 3113 /** 3114 * Don’t trade height-for-width or width-for-height 3115 */ 3116 CONSTANT_SIZE = 2, 3117 } 3118 alias GtkSizeRequestMode SizeRequestMode; 3119 3120 /** 3121 * Determines the direction of a sort. 3122 */ 3123 public enum GtkSortType 3124 { 3125 /** 3126 * Sorting is in ascending order. 3127 */ 3128 ASCENDING = 0, 3129 /** 3130 * Sorting is in descending order. 3131 */ 3132 DESCENDING = 1, 3133 } 3134 alias GtkSortType SortType; 3135 3136 /** 3137 * The spin button update policy determines whether the spin button displays 3138 * values even if they are outside the bounds of its adjustment. 3139 * See gtk_spin_button_set_update_policy(). 3140 */ 3141 public enum GtkSpinButtonUpdatePolicy 3142 { 3143 /** 3144 * When refreshing your #GtkSpinButton, the value is 3145 * always displayed 3146 */ 3147 ALWAYS = 0, 3148 /** 3149 * When refreshing your #GtkSpinButton, the value is 3150 * only displayed if it is valid within the bounds of the spin button's 3151 * adjustment 3152 */ 3153 IF_VALID = 1, 3154 } 3155 alias GtkSpinButtonUpdatePolicy SpinButtonUpdatePolicy; 3156 3157 /** 3158 * The values of the GtkSpinType enumeration are used to specify the 3159 * change to make in gtk_spin_button_spin(). 3160 */ 3161 public enum GtkSpinType 3162 { 3163 /** 3164 * Increment by the adjustments step increment. 3165 */ 3166 STEP_FORWARD = 0, 3167 /** 3168 * Decrement by the adjustments step increment. 3169 */ 3170 STEP_BACKWARD = 1, 3171 /** 3172 * Increment by the adjustments page increment. 3173 */ 3174 PAGE_FORWARD = 2, 3175 /** 3176 * Decrement by the adjustments page increment. 3177 */ 3178 PAGE_BACKWARD = 3, 3179 /** 3180 * Go to the adjustments lower bound. 3181 */ 3182 HOME = 4, 3183 /** 3184 * Go to the adjustments upper bound. 3185 */ 3186 END = 5, 3187 /** 3188 * Change by a specified amount. 3189 */ 3190 USER_DEFINED = 6, 3191 } 3192 alias GtkSpinType SpinType; 3193 3194 /** 3195 * These enumeration values describe the possible transitions 3196 * between pages in a #GtkStack widget. 3197 * 3198 * New values may be added to this enumeration over time. 3199 */ 3200 public enum GtkStackTransitionType 3201 { 3202 /** 3203 * No transition 3204 */ 3205 NONE = 0, 3206 /** 3207 * A cross-fade 3208 */ 3209 CROSSFADE = 1, 3210 /** 3211 * Slide from left to right 3212 */ 3213 SLIDE_RIGHT = 2, 3214 /** 3215 * Slide from right to left 3216 */ 3217 SLIDE_LEFT = 3, 3218 /** 3219 * Slide from bottom up 3220 */ 3221 SLIDE_UP = 4, 3222 /** 3223 * Slide from top down 3224 */ 3225 SLIDE_DOWN = 5, 3226 /** 3227 * Slide from left or right according to the children order 3228 */ 3229 SLIDE_LEFT_RIGHT = 6, 3230 /** 3231 * Slide from top down or bottom up according to the order 3232 */ 3233 SLIDE_UP_DOWN = 7, 3234 /** 3235 * Cover the old page by sliding up. Since 3.12 3236 */ 3237 OVER_UP = 8, 3238 /** 3239 * Cover the old page by sliding down. Since: 3.12 3240 */ 3241 OVER_DOWN = 9, 3242 /** 3243 * Cover the old page by sliding to the left. Since: 3.12 3244 */ 3245 OVER_LEFT = 10, 3246 /** 3247 * Cover the old page by sliding to the right. Since: 3.12 3248 */ 3249 OVER_RIGHT = 11, 3250 /** 3251 * Uncover the new page by sliding up. Since 3.12 3252 */ 3253 UNDER_UP = 12, 3254 /** 3255 * Uncover the new page by sliding down. Since: 3.12 3256 */ 3257 UNDER_DOWN = 13, 3258 /** 3259 * Uncover the new page by sliding to the left. Since: 3.12 3260 */ 3261 UNDER_LEFT = 14, 3262 /** 3263 * Uncover the new page by sliding to the right. Since: 3.12 3264 */ 3265 UNDER_RIGHT = 15, 3266 /** 3267 * Cover the old page sliding up or uncover the new page sliding down, according to order. Since: 3.12 3268 */ 3269 OVER_UP_DOWN = 16, 3270 /** 3271 * Cover the old page sliding down or uncover the new page sliding up, according to order. Since: 3.14 3272 */ 3273 OVER_DOWN_UP = 17, 3274 /** 3275 * Cover the old page sliding left or uncover the new page sliding right, according to order. Since: 3.14 3276 */ 3277 OVER_LEFT_RIGHT = 18, 3278 /** 3279 * Cover the old page sliding right or uncover the new page sliding left, according to order. Since: 3.14 3280 */ 3281 OVER_RIGHT_LEFT = 19, 3282 } 3283 alias GtkStackTransitionType StackTransitionType; 3284 3285 /** 3286 * Describes a widget state. Widget states are used to match the widget 3287 * against CSS pseudo-classes. Note that GTK extends the regular CSS 3288 * classes and sometimes uses different names. 3289 */ 3290 public enum GtkStateFlags 3291 { 3292 /** 3293 * State during normal operation. 3294 */ 3295 NORMAL = 0, 3296 /** 3297 * Widget is active. 3298 */ 3299 ACTIVE = 1, 3300 /** 3301 * Widget has a mouse pointer over it. 3302 */ 3303 PRELIGHT = 2, 3304 /** 3305 * Widget is selected. 3306 */ 3307 SELECTED = 4, 3308 /** 3309 * Widget is insensitive. 3310 */ 3311 INSENSITIVE = 8, 3312 /** 3313 * Widget is inconsistent. 3314 */ 3315 INCONSISTENT = 16, 3316 /** 3317 * Widget has the keyboard focus. 3318 */ 3319 FOCUSED = 32, 3320 /** 3321 * Widget is in a background toplevel window. 3322 */ 3323 BACKDROP = 64, 3324 /** 3325 * Widget is in left-to-right text direction. Since 3.8 3326 */ 3327 DIR_LTR = 128, 3328 /** 3329 * Widget is in right-to-left text direction. Since 3.8 3330 */ 3331 DIR_RTL = 256, 3332 /** 3333 * Widget is a link. Since 3.12 3334 */ 3335 LINK = 512, 3336 /** 3337 * The location the widget points to has already been visited. Since 3.12 3338 */ 3339 VISITED = 1024, 3340 /** 3341 * Widget is checked. Since 3.14 3342 */ 3343 CHECKED = 2048, 3344 /** 3345 * Widget is highlighted as a drop target for DND. Since 3.20 3346 */ 3347 DROP_ACTIVE = 4096, 3348 } 3349 alias GtkStateFlags StateFlags; 3350 3351 /** 3352 * This type indicates the current state of a widget; the state determines how 3353 * the widget is drawn. The #GtkStateType enumeration is also used to 3354 * identify different colors in a #GtkStyle for drawing, so states can be 3355 * used for subparts of a widget as well as entire widgets. 3356 * 3357 * Deprecated: All APIs that are using this enumeration have been deprecated 3358 * in favor of alternatives using #GtkStateFlags. 3359 */ 3360 public enum GtkStateType 3361 { 3362 /** 3363 * State during normal operation. 3364 */ 3365 NORMAL = 0, 3366 /** 3367 * State of a currently active widget, such as a depressed button. 3368 */ 3369 ACTIVE = 1, 3370 /** 3371 * State indicating that the mouse pointer is over 3372 * the widget and the widget will respond to mouse clicks. 3373 */ 3374 PRELIGHT = 2, 3375 /** 3376 * State of a selected item, such the selected row in a list. 3377 */ 3378 SELECTED = 3, 3379 /** 3380 * State indicating that the widget is 3381 * unresponsive to user actions. 3382 */ 3383 INSENSITIVE = 4, 3384 /** 3385 * The widget is inconsistent, such as checkbuttons 3386 * or radiobuttons that aren’t either set to %TRUE nor %FALSE, 3387 * or buttons requiring the user attention. 3388 */ 3389 INCONSISTENT = 5, 3390 /** 3391 * The widget has the keyboard focus. 3392 */ 3393 FOCUSED = 6, 3394 } 3395 alias GtkStateType StateType; 3396 3397 /** 3398 * Flags that modify the behavior of gtk_style_context_to_string(). 3399 * New values may be added to this enumeration. 3400 */ 3401 public enum GtkStyleContextPrintFlags 3402 { 3403 NONE = 0, 3404 /** 3405 * Print the entire tree of 3406 * CSS nodes starting at the style context's node 3407 */ 3408 RECURSE = 1, 3409 /** 3410 * Show the values of the 3411 * CSS properties for each node 3412 */ 3413 SHOW_STYLE = 2, 3414 } 3415 alias GtkStyleContextPrintFlags StyleContextPrintFlags; 3416 3417 /** 3418 * The #GtkTargetFlags enumeration is used to specify 3419 * constraints on a #GtkTargetEntry. 3420 */ 3421 public enum GtkTargetFlags 3422 { 3423 /** 3424 * If this is set, the target will only be selected 3425 * for drags within a single application. 3426 */ 3427 SAME_APP = 1, 3428 /** 3429 * If this is set, the target will only be selected 3430 * for drags within a single widget. 3431 */ 3432 SAME_WIDGET = 2, 3433 /** 3434 * If this is set, the target will not be selected 3435 * for drags within a single application. 3436 */ 3437 OTHER_APP = 4, 3438 /** 3439 * If this is set, the target will not be selected 3440 * for drags withing a single widget. 3441 */ 3442 OTHER_WIDGET = 8, 3443 } 3444 alias GtkTargetFlags TargetFlags; 3445 3446 /** 3447 * These values are used as “info” for the targets contained in the 3448 * lists returned by gtk_text_buffer_get_copy_target_list() and 3449 * gtk_text_buffer_get_paste_target_list(). 3450 * 3451 * The values counts down from `-1` to avoid clashes 3452 * with application added drag destinations which usually start at 0. 3453 */ 3454 public enum GtkTextBufferTargetInfo 3455 { 3456 /** 3457 * Buffer contents 3458 */ 3459 BUFFER_CONTENTS = -1, 3460 /** 3461 * Rich text 3462 */ 3463 RICH_TEXT = -2, 3464 /** 3465 * Text 3466 */ 3467 TEXT = -3, 3468 } 3469 alias GtkTextBufferTargetInfo TextBufferTargetInfo; 3470 3471 /** 3472 * Reading directions for text. 3473 */ 3474 public enum GtkTextDirection 3475 { 3476 /** 3477 * No direction. 3478 */ 3479 NONE = 0, 3480 /** 3481 * Left to right text direction. 3482 */ 3483 LTR = 1, 3484 /** 3485 * Right to left text direction. 3486 */ 3487 RTL = 2, 3488 } 3489 alias GtkTextDirection TextDirection; 3490 3491 /** 3492 * Granularity types that extend the text selection. Use the 3493 * #GtkTextView::extend-selection signal to customize the selection. 3494 * 3495 * Since: 3.16 3496 */ 3497 public enum GtkTextExtendSelection 3498 { 3499 /** 3500 * Selects the current word. It is triggered by 3501 * a double-click for example. 3502 */ 3503 WORD = 0, 3504 /** 3505 * Selects the current line. It is triggered by 3506 * a triple-click for example. 3507 */ 3508 LINE = 1, 3509 } 3510 alias GtkTextExtendSelection TextExtendSelection; 3511 3512 /** 3513 * Flags affecting how a search is done. 3514 * 3515 * If neither #GTK_TEXT_SEARCH_VISIBLE_ONLY nor #GTK_TEXT_SEARCH_TEXT_ONLY are 3516 * enabled, the match must be exact; the special 0xFFFC character will match 3517 * embedded pixbufs or child widgets. 3518 */ 3519 public enum GtkTextSearchFlags 3520 { 3521 /** 3522 * Search only visible data. A search match may 3523 * have invisible text interspersed. 3524 */ 3525 VISIBLE_ONLY = 1, 3526 /** 3527 * Search only text. A match may have pixbufs or 3528 * child widgets mixed inside the matched range. 3529 */ 3530 TEXT_ONLY = 2, 3531 /** 3532 * The text will be matched regardless of 3533 * what case it is in. 3534 */ 3535 CASE_INSENSITIVE = 4, 3536 } 3537 alias GtkTextSearchFlags TextSearchFlags; 3538 3539 /** 3540 * Used to reference the layers of #GtkTextView for the purpose of customized 3541 * drawing with the ::draw_layer vfunc. 3542 */ 3543 public enum GtkTextViewLayer 3544 { 3545 /** 3546 * Old deprecated layer, use %GTK_TEXT_VIEW_LAYER_BELOW_TEXT instead 3547 */ 3548 BELOW = 0, 3549 /** 3550 * Old deprecated layer, use %GTK_TEXT_VIEW_LAYER_ABOVE_TEXT instead 3551 */ 3552 ABOVE = 1, 3553 /** 3554 * The layer rendered below the text (but above the background). Since: 3.20 3555 */ 3556 BELOW_TEXT = 2, 3557 /** 3558 * The layer rendered above the text. Since: 3.20 3559 */ 3560 ABOVE_TEXT = 3, 3561 } 3562 alias GtkTextViewLayer TextViewLayer; 3563 3564 /** 3565 * Used to reference the parts of #GtkTextView. 3566 */ 3567 public enum GtkTextWindowType 3568 { 3569 /** 3570 * Invalid value, used as a marker 3571 */ 3572 PRIVATE = 0, 3573 /** 3574 * Window that floats over scrolling areas. 3575 */ 3576 WIDGET = 1, 3577 /** 3578 * Scrollable text window. 3579 */ 3580 TEXT = 2, 3581 /** 3582 * Left side border window. 3583 */ 3584 LEFT = 3, 3585 /** 3586 * Right side border window. 3587 */ 3588 RIGHT = 4, 3589 /** 3590 * Top border window. 3591 */ 3592 TOP = 5, 3593 /** 3594 * Bottom border window. 3595 */ 3596 BOTTOM = 6, 3597 } 3598 alias GtkTextWindowType TextWindowType; 3599 3600 /** 3601 * Flags used to specify the supported drag targets. 3602 */ 3603 public enum GtkToolPaletteDragTargets 3604 { 3605 /** 3606 * Support drag of items. 3607 */ 3608 ITEMS = 1, 3609 /** 3610 * Support drag of groups. 3611 */ 3612 GROUPS = 2, 3613 } 3614 alias GtkToolPaletteDragTargets ToolPaletteDragTargets; 3615 3616 /** 3617 * Whether spacers are vertical lines or just blank. 3618 */ 3619 public enum GtkToolbarSpaceStyle 3620 { 3621 /** 3622 * Use blank spacers. 3623 */ 3624 EMPTY = 0, 3625 /** 3626 * Use vertical lines for spacers. 3627 */ 3628 LINE = 1, 3629 } 3630 alias GtkToolbarSpaceStyle ToolbarSpaceStyle; 3631 3632 /** 3633 * Used to customize the appearance of a #GtkToolbar. Note that 3634 * setting the toolbar style overrides the user’s preferences 3635 * for the default toolbar style. Note that if the button has only 3636 * a label set and GTK_TOOLBAR_ICONS is used, the label will be 3637 * visible, and vice versa. 3638 */ 3639 public enum GtkToolbarStyle 3640 { 3641 /** 3642 * Buttons display only icons in the toolbar. 3643 */ 3644 ICONS = 0, 3645 /** 3646 * Buttons display only text labels in the toolbar. 3647 */ 3648 TEXT = 1, 3649 /** 3650 * Buttons display text and icons in the toolbar. 3651 */ 3652 BOTH = 2, 3653 /** 3654 * Buttons display icons and text alongside each 3655 * other, rather than vertically stacked 3656 */ 3657 BOTH_HORIZ = 3, 3658 } 3659 alias GtkToolbarStyle ToolbarStyle; 3660 3661 /** 3662 * These flags indicate various properties of a #GtkTreeModel. 3663 * 3664 * They are returned by gtk_tree_model_get_flags(), and must be 3665 * static for the lifetime of the object. A more complete description 3666 * of #GTK_TREE_MODEL_ITERS_PERSIST can be found in the overview of 3667 * this section. 3668 */ 3669 public enum GtkTreeModelFlags 3670 { 3671 /** 3672 * iterators survive all signals 3673 * emitted by the tree 3674 */ 3675 ITERS_PERSIST = 1, 3676 /** 3677 * the model is a list only, and never 3678 * has children 3679 */ 3680 LIST_ONLY = 2, 3681 } 3682 alias GtkTreeModelFlags TreeModelFlags; 3683 3684 /** 3685 * The sizing method the column uses to determine its width. Please note 3686 * that @GTK_TREE_VIEW_COLUMN_AUTOSIZE are inefficient for large views, and 3687 * can make columns appear choppy. 3688 */ 3689 public enum GtkTreeViewColumnSizing 3690 { 3691 /** 3692 * Columns only get bigger in reaction to changes in the model 3693 */ 3694 GROW_ONLY = 0, 3695 /** 3696 * Columns resize to be the optimal size everytime the model changes. 3697 */ 3698 AUTOSIZE = 1, 3699 /** 3700 * Columns are a fixed numbers of pixels wide. 3701 */ 3702 FIXED = 2, 3703 } 3704 alias GtkTreeViewColumnSizing TreeViewColumnSizing; 3705 3706 /** 3707 * An enum for determining where a dropped row goes. 3708 */ 3709 public enum GtkTreeViewDropPosition 3710 { 3711 /** 3712 * dropped row is inserted before 3713 */ 3714 BEFORE = 0, 3715 /** 3716 * dropped row is inserted after 3717 */ 3718 AFTER = 1, 3719 /** 3720 * dropped row becomes a child or is inserted before 3721 */ 3722 INTO_OR_BEFORE = 2, 3723 /** 3724 * dropped row becomes a child or is inserted after 3725 */ 3726 INTO_OR_AFTER = 3, 3727 } 3728 alias GtkTreeViewDropPosition TreeViewDropPosition; 3729 3730 /** 3731 * Used to indicate which grid lines to draw in a tree view. 3732 */ 3733 public enum GtkTreeViewGridLines 3734 { 3735 /** 3736 * No grid lines. 3737 */ 3738 NONE = 0, 3739 /** 3740 * Horizontal grid lines. 3741 */ 3742 HORIZONTAL = 1, 3743 /** 3744 * Vertical grid lines. 3745 */ 3746 VERTICAL = 2, 3747 /** 3748 * Horizontal and vertical grid lines. 3749 */ 3750 BOTH = 3, 3751 } 3752 alias GtkTreeViewGridLines TreeViewGridLines; 3753 3754 /** 3755 * These enumeration values are used by gtk_ui_manager_add_ui() to determine 3756 * what UI element to create. 3757 */ 3758 public enum GtkUIManagerItemType 3759 { 3760 /** 3761 * Pick the type of the UI element according to context. 3762 */ 3763 AUTO = 0, 3764 /** 3765 * Create a menubar. 3766 */ 3767 MENUBAR = 1, 3768 /** 3769 * Create a menu. 3770 */ 3771 MENU = 2, 3772 /** 3773 * Create a toolbar. 3774 */ 3775 TOOLBAR = 4, 3776 /** 3777 * Insert a placeholder. 3778 */ 3779 PLACEHOLDER = 8, 3780 /** 3781 * Create a popup menu. 3782 */ 3783 POPUP = 16, 3784 /** 3785 * Create a menuitem. 3786 */ 3787 MENUITEM = 32, 3788 /** 3789 * Create a toolitem. 3790 */ 3791 TOOLITEM = 64, 3792 /** 3793 * Create a separator. 3794 */ 3795 SEPARATOR = 128, 3796 /** 3797 * Install an accelerator. 3798 */ 3799 ACCELERATOR = 256, 3800 /** 3801 * Same as %GTK_UI_MANAGER_POPUP, but the 3802 * actions’ accelerators are shown. 3803 */ 3804 POPUP_WITH_ACCELS = 512, 3805 } 3806 alias GtkUIManagerItemType UIManagerItemType; 3807 3808 /** 3809 * See also gtk_print_settings_set_paper_width(). 3810 */ 3811 public enum GtkUnit 3812 { 3813 /** 3814 * No units. 3815 */ 3816 NONE = 0, 3817 /** 3818 * Dimensions in points. 3819 */ 3820 POINTS = 1, 3821 /** 3822 * Dimensions in inches. 3823 */ 3824 INCH = 2, 3825 /** 3826 * Dimensions in millimeters 3827 */ 3828 MM = 3, 3829 } 3830 alias GtkUnit Unit; 3831 3832 /** 3833 * Kinds of widget-specific help. Used by the ::show-help signal. 3834 */ 3835 public enum GtkWidgetHelpType 3836 { 3837 /** 3838 * Tooltip. 3839 */ 3840 TOOLTIP = 0, 3841 /** 3842 * What’s this. 3843 */ 3844 WHATS_THIS = 1, 3845 } 3846 alias GtkWidgetHelpType WidgetHelpType; 3847 3848 /** 3849 * Window placement can be influenced using this enumeration. Note that 3850 * using #GTK_WIN_POS_CENTER_ALWAYS is almost always a bad idea. 3851 * It won’t necessarily work well with all window managers or on all windowing systems. 3852 */ 3853 public enum GtkWindowPosition 3854 { 3855 /** 3856 * No influence is made on placement. 3857 */ 3858 NONE = 0, 3859 /** 3860 * Windows should be placed in the center of the screen. 3861 */ 3862 CENTER = 1, 3863 /** 3864 * Windows should be placed at the current mouse position. 3865 */ 3866 MOUSE = 2, 3867 /** 3868 * Keep window centered as it changes size, etc. 3869 */ 3870 CENTER_ALWAYS = 3, 3871 /** 3872 * Center the window on its transient 3873 * parent (see gtk_window_set_transient_for()). 3874 */ 3875 CENTER_ON_PARENT = 4, 3876 } 3877 alias GtkWindowPosition WindowPosition; 3878 3879 /** 3880 * A #GtkWindow can be one of these types. Most things you’d consider a 3881 * “window” should have type #GTK_WINDOW_TOPLEVEL; windows with this type 3882 * are managed by the window manager and have a frame by default (call 3883 * gtk_window_set_decorated() to toggle the frame). Windows with type 3884 * #GTK_WINDOW_POPUP are ignored by the window manager; window manager 3885 * keybindings won’t work on them, the window manager won’t decorate the 3886 * window with a frame, many GTK+ features that rely on the window 3887 * manager will not work (e.g. resize grips and 3888 * maximization/minimization). #GTK_WINDOW_POPUP is used to implement 3889 * widgets such as #GtkMenu or tooltips that you normally don’t think of 3890 * as windows per se. Nearly all windows should be #GTK_WINDOW_TOPLEVEL. 3891 * In particular, do not use #GTK_WINDOW_POPUP just to turn off 3892 * the window borders; use gtk_window_set_decorated() for that. 3893 */ 3894 public enum GtkWindowType 3895 { 3896 /** 3897 * A regular window, such as a dialog. 3898 */ 3899 TOPLEVEL = 0, 3900 /** 3901 * A special window such as a tooltip. 3902 */ 3903 POPUP = 1, 3904 } 3905 alias GtkWindowType WindowType; 3906 3907 /** 3908 * Describes a type of line wrapping. 3909 */ 3910 public enum GtkWrapMode 3911 { 3912 /** 3913 * do not wrap lines; just make the text area wider 3914 */ 3915 NONE = 0, 3916 /** 3917 * wrap text, breaking lines anywhere the cursor can 3918 * appear (between characters, usually - if you want to be technical, 3919 * between graphemes, see pango_get_log_attrs()) 3920 */ 3921 CHAR = 1, 3922 /** 3923 * wrap text, breaking lines in between words 3924 */ 3925 WORD = 2, 3926 /** 3927 * wrap text, breaking lines in between words, or if 3928 * that is not enough, also between graphemes 3929 */ 3930 WORD_CHAR = 3, 3931 } 3932 alias GtkWrapMode WrapMode; 3933 3934 struct GtkAboutDialog 3935 { 3936 GtkDialog parentInstance; 3937 GtkAboutDialogPrivate* priv; 3938 } 3939 3940 struct GtkAboutDialogClass 3941 { 3942 GtkDialogClass parentClass; 3943 /** */ 3944 extern(C) int function(GtkAboutDialog* dialog, const(char)* uri) activateLink; 3945 /** */ 3946 extern(C) void function() GtkReserved1; 3947 /** */ 3948 extern(C) void function() GtkReserved2; 3949 /** */ 3950 extern(C) void function() GtkReserved3; 3951 /** */ 3952 extern(C) void function() GtkReserved4; 3953 } 3954 3955 struct GtkAboutDialogPrivate; 3956 3957 struct GtkAccelGroup 3958 { 3959 GObject parent; 3960 GtkAccelGroupPrivate* priv; 3961 } 3962 3963 struct GtkAccelGroupClass 3964 { 3965 /** 3966 * The parent class. 3967 */ 3968 GObjectClass parentClass; 3969 /** */ 3970 extern(C) void function(GtkAccelGroup* accelGroup, uint keyval, GdkModifierType modifier, GClosure* accelClosure) accelChanged; 3971 /** */ 3972 extern(C) void function() GtkReserved1; 3973 /** */ 3974 extern(C) void function() GtkReserved2; 3975 /** */ 3976 extern(C) void function() GtkReserved3; 3977 /** */ 3978 extern(C) void function() GtkReserved4; 3979 } 3980 3981 struct GtkAccelGroupEntry 3982 { 3983 GtkAccelKey key; 3984 GClosure* closure; 3985 GQuark accelPathQuark; 3986 } 3987 3988 struct GtkAccelGroupPrivate; 3989 3990 struct GtkAccelKey 3991 { 3992 /** 3993 * The accelerator keyval 3994 */ 3995 uint accelKey; 3996 /** 3997 * The accelerator modifiers 3998 */ 3999 GdkModifierType accelMods; 4000 import std.bitmanip: bitfields; 4001 mixin(bitfields!( 4002 uint, "accelFlags", 16, 4003 uint, "", 16 4004 )); 4005 } 4006 4007 struct GtkAccelLabel 4008 { 4009 GtkLabel label; 4010 GtkAccelLabelPrivate* priv; 4011 } 4012 4013 struct GtkAccelLabelClass 4014 { 4015 GtkLabelClass parentClass; 4016 char* signalQuote1; 4017 char* signalQuote2; 4018 char* modNameShift; 4019 char* modNameControl; 4020 char* modNameAlt; 4021 char* modSeparator; 4022 /** */ 4023 extern(C) void function() GtkReserved1; 4024 /** */ 4025 extern(C) void function() GtkReserved2; 4026 /** */ 4027 extern(C) void function() GtkReserved3; 4028 /** */ 4029 extern(C) void function() GtkReserved4; 4030 } 4031 4032 struct GtkAccelLabelPrivate; 4033 4034 struct GtkAccelMap; 4035 4036 struct GtkAccelMapClass; 4037 4038 struct GtkAccessible 4039 { 4040 AtkObject parent; 4041 GtkAccessiblePrivate* priv; 4042 } 4043 4044 struct GtkAccessibleClass 4045 { 4046 AtkObjectClass parentClass; 4047 /** */ 4048 extern(C) void function(GtkAccessible* accessible) connectWidgetDestroyed; 4049 /** */ 4050 extern(C) void function(GtkAccessible* accessible) widgetSet; 4051 /** */ 4052 extern(C) void function(GtkAccessible* accessible) widgetUnset; 4053 /** */ 4054 extern(C) void function() GtkReserved3; 4055 /** */ 4056 extern(C) void function() GtkReserved4; 4057 } 4058 4059 struct GtkAccessiblePrivate; 4060 4061 struct GtkAction 4062 { 4063 GObject object; 4064 GtkActionPrivate* privateData; 4065 } 4066 4067 struct GtkActionBar 4068 { 4069 GtkBin bin; 4070 } 4071 4072 struct GtkActionBarClass 4073 { 4074 GtkBinClass parentClass; 4075 /** */ 4076 extern(C) void function() GtkReserved1; 4077 /** */ 4078 extern(C) void function() GtkReserved2; 4079 /** */ 4080 extern(C) void function() GtkReserved3; 4081 /** */ 4082 extern(C) void function() GtkReserved4; 4083 } 4084 4085 struct GtkActionBarPrivate; 4086 4087 struct GtkActionClass 4088 { 4089 /** 4090 * The parent class. 4091 */ 4092 GObjectClass parentClass; 4093 /** */ 4094 extern(C) void function(GtkAction* action) activate; 4095 GType menuItemType; 4096 GType toolbarItemType; 4097 /** 4098 * 4099 * Params: 4100 * action = the action object 4101 * Returns: a menu item connected to the action. 4102 */ 4103 extern(C) GtkWidget* function(GtkAction* action) createMenuItem; 4104 /** 4105 * 4106 * Params: 4107 * action = the action object 4108 * Returns: a toolbar item connected to the action. 4109 */ 4110 extern(C) GtkWidget* function(GtkAction* action) createToolItem; 4111 /** */ 4112 extern(C) void function(GtkAction* action, GtkWidget* proxy) connectProxy; 4113 /** */ 4114 extern(C) void function(GtkAction* action, GtkWidget* proxy) disconnectProxy; 4115 /** 4116 * 4117 * Params: 4118 * action = a #GtkAction 4119 * Returns: the menu item provided by the 4120 * action, or %NULL. 4121 */ 4122 extern(C) GtkWidget* function(GtkAction* action) createMenu; 4123 /** */ 4124 extern(C) void function() GtkReserved1; 4125 /** */ 4126 extern(C) void function() GtkReserved2; 4127 /** */ 4128 extern(C) void function() GtkReserved3; 4129 /** */ 4130 extern(C) void function() GtkReserved4; 4131 } 4132 4133 /** 4134 * #GtkActionEntry structs are used with gtk_action_group_add_actions() to 4135 * construct actions. 4136 */ 4137 struct GtkActionEntry 4138 { 4139 /** 4140 * The name of the action. 4141 */ 4142 const(char)* name; 4143 /** 4144 * The stock id for the action, or the name of an icon from the 4145 * icon theme. 4146 */ 4147 const(char)* stockId; 4148 /** 4149 * The label for the action. This field should typically be marked 4150 * for translation, see gtk_action_group_set_translation_domain(). If 4151 * @label is %NULL, the label of the stock item with id @stock_id is used. 4152 */ 4153 const(char)* label; 4154 /** 4155 * The accelerator for the action, in the format understood by 4156 * gtk_accelerator_parse(). 4157 */ 4158 const(char)* accelerator; 4159 /** 4160 * The tooltip for the action. This field should typically be 4161 * marked for translation, see gtk_action_group_set_translation_domain(). 4162 */ 4163 const(char)* tooltip; 4164 /** 4165 * The function to call when the action is activated. 4166 */ 4167 GCallback callback; 4168 } 4169 4170 struct GtkActionGroup 4171 { 4172 GObject parent; 4173 GtkActionGroupPrivate* priv; 4174 } 4175 4176 struct GtkActionGroupClass 4177 { 4178 /** 4179 * The parent class. 4180 */ 4181 GObjectClass parentClass; 4182 /** 4183 * 4184 * Params: 4185 * actionGroup = the action group 4186 * actionName = the name of the action 4187 * Returns: the action, or %NULL if no action by that name exists 4188 */ 4189 extern(C) GtkAction* function(GtkActionGroup* actionGroup, const(char)* actionName) getAction; 4190 /** */ 4191 extern(C) void function() GtkReserved1; 4192 /** */ 4193 extern(C) void function() GtkReserved2; 4194 /** */ 4195 extern(C) void function() GtkReserved3; 4196 /** */ 4197 extern(C) void function() GtkReserved4; 4198 } 4199 4200 struct GtkActionGroupPrivate; 4201 4202 struct GtkActionPrivate; 4203 4204 struct GtkActionable; 4205 4206 /** 4207 * The interface vtable for #GtkActionable. 4208 */ 4209 struct GtkActionableInterface 4210 { 4211 GTypeInterface gIface; 4212 /** 4213 * 4214 * Params: 4215 * actionable = a #GtkActionable widget 4216 * Returns: the action name, or %NULL if none is set 4217 */ 4218 extern(C) const(char)* function(GtkActionable* actionable) getActionName; 4219 /** */ 4220 extern(C) void function(GtkActionable* actionable, const(char)* actionName) setActionName; 4221 /** 4222 * 4223 * Params: 4224 * actionable = a #GtkActionable widget 4225 * Returns: the current target value 4226 */ 4227 extern(C) GVariant* function(GtkActionable* actionable) getActionTargetValue; 4228 /** */ 4229 extern(C) void function(GtkActionable* actionable, GVariant* targetValue) setActionTargetValue; 4230 } 4231 4232 struct GtkActivatable; 4233 4234 /** 4235 * > This method can be called with a %NULL action at times. 4236 * 4237 * Since: 2.16 4238 */ 4239 struct GtkActivatableIface 4240 { 4241 GTypeInterface gIface; 4242 /** */ 4243 extern(C) void function(GtkActivatable* activatable, GtkAction* action, const(char)* propertyName) update; 4244 /** */ 4245 extern(C) void function(GtkActivatable* activatable, GtkAction* action) syncActionProperties; 4246 } 4247 4248 struct GtkAdjustment 4249 { 4250 GObject parentInstance; 4251 GtkAdjustmentPrivate* priv; 4252 } 4253 4254 struct GtkAdjustmentClass 4255 { 4256 GObjectClass parentClass; 4257 /** */ 4258 extern(C) void function(GtkAdjustment* adjustment) changed; 4259 /** */ 4260 extern(C) void function(GtkAdjustment* adjustment) valueChanged; 4261 /** */ 4262 extern(C) void function() GtkReserved1; 4263 /** */ 4264 extern(C) void function() GtkReserved2; 4265 /** */ 4266 extern(C) void function() GtkReserved3; 4267 /** */ 4268 extern(C) void function() GtkReserved4; 4269 } 4270 4271 struct GtkAdjustmentPrivate; 4272 4273 struct GtkAlignment 4274 { 4275 GtkBin bin; 4276 GtkAlignmentPrivate* priv; 4277 } 4278 4279 struct GtkAlignmentClass 4280 { 4281 /** 4282 * The parent class. 4283 */ 4284 GtkBinClass parentClass; 4285 /** */ 4286 extern(C) void function() GtkReserved1; 4287 /** */ 4288 extern(C) void function() GtkReserved2; 4289 /** */ 4290 extern(C) void function() GtkReserved3; 4291 /** */ 4292 extern(C) void function() GtkReserved4; 4293 } 4294 4295 struct GtkAlignmentPrivate; 4296 4297 struct GtkAppChooser; 4298 4299 struct GtkAppChooserButton 4300 { 4301 GtkComboBox parent; 4302 GtkAppChooserButtonPrivate* priv; 4303 } 4304 4305 struct GtkAppChooserButtonClass 4306 { 4307 /** 4308 * The parent class. 4309 */ 4310 GtkComboBoxClass parentClass; 4311 /** */ 4312 extern(C) void function(GtkAppChooserButton* self, const(char)* itemName) customItemActivated; 4313 void*[16] padding; 4314 } 4315 4316 struct GtkAppChooserButtonPrivate; 4317 4318 struct GtkAppChooserDialog 4319 { 4320 GtkDialog parent; 4321 GtkAppChooserDialogPrivate* priv; 4322 } 4323 4324 struct GtkAppChooserDialogClass 4325 { 4326 /** 4327 * The parent class. 4328 */ 4329 GtkDialogClass parentClass; 4330 void*[16] padding; 4331 } 4332 4333 struct GtkAppChooserDialogPrivate; 4334 4335 struct GtkAppChooserWidget 4336 { 4337 GtkBox parent; 4338 GtkAppChooserWidgetPrivate* priv; 4339 } 4340 4341 struct GtkAppChooserWidgetClass 4342 { 4343 /** 4344 * The parent class. 4345 */ 4346 GtkBoxClass parentClass; 4347 /** */ 4348 extern(C) void function(GtkAppChooserWidget* self, GAppInfo* appInfo) applicationSelected; 4349 /** */ 4350 extern(C) void function(GtkAppChooserWidget* self, GAppInfo* appInfo) applicationActivated; 4351 /** */ 4352 extern(C) void function(GtkAppChooserWidget* self, GtkMenu* menu, GAppInfo* appInfo) populatePopup; 4353 void*[16] padding; 4354 } 4355 4356 struct GtkAppChooserWidgetPrivate; 4357 4358 struct GtkApplication 4359 { 4360 GApplication parent; 4361 GtkApplicationPrivate* priv; 4362 } 4363 4364 struct GtkApplicationClass 4365 { 4366 /** 4367 * The parent class. 4368 */ 4369 GApplicationClass parentClass; 4370 /** */ 4371 extern(C) void function(GtkApplication* application, GtkWindow* window) windowAdded; 4372 /** */ 4373 extern(C) void function(GtkApplication* application, GtkWindow* window) windowRemoved; 4374 void*[12] padding; 4375 } 4376 4377 struct GtkApplicationPrivate; 4378 4379 struct GtkApplicationWindow 4380 { 4381 GtkWindow parentInstance; 4382 GtkApplicationWindowPrivate* priv; 4383 } 4384 4385 struct GtkApplicationWindowClass 4386 { 4387 /** 4388 * The parent class. 4389 */ 4390 GtkWindowClass parentClass; 4391 void*[14] padding; 4392 } 4393 4394 struct GtkApplicationWindowPrivate; 4395 4396 struct GtkArrow 4397 { 4398 GtkMisc misc; 4399 GtkArrowPrivate* priv; 4400 } 4401 4402 struct GtkArrowAccessible 4403 { 4404 GtkWidgetAccessible parent; 4405 GtkArrowAccessiblePrivate* priv; 4406 } 4407 4408 struct GtkArrowAccessibleClass 4409 { 4410 GtkWidgetAccessibleClass parentClass; 4411 } 4412 4413 struct GtkArrowAccessiblePrivate; 4414 4415 struct GtkArrowClass 4416 { 4417 GtkMiscClass parentClass; 4418 /** */ 4419 extern(C) void function() GtkReserved1; 4420 /** */ 4421 extern(C) void function() GtkReserved2; 4422 /** */ 4423 extern(C) void function() GtkReserved3; 4424 /** */ 4425 extern(C) void function() GtkReserved4; 4426 } 4427 4428 struct GtkArrowPrivate; 4429 4430 struct GtkAspectFrame 4431 { 4432 GtkFrame frame; 4433 GtkAspectFramePrivate* priv; 4434 } 4435 4436 struct GtkAspectFrameClass 4437 { 4438 /** 4439 * The parent class. 4440 */ 4441 GtkFrameClass parentClass; 4442 /** */ 4443 extern(C) void function() GtkReserved1; 4444 /** */ 4445 extern(C) void function() GtkReserved2; 4446 /** */ 4447 extern(C) void function() GtkReserved3; 4448 /** */ 4449 extern(C) void function() GtkReserved4; 4450 } 4451 4452 struct GtkAspectFramePrivate; 4453 4454 struct GtkAssistant 4455 { 4456 GtkWindow parent; 4457 GtkAssistantPrivate* priv; 4458 } 4459 4460 struct GtkAssistantClass 4461 { 4462 /** 4463 * The parent class. 4464 */ 4465 GtkWindowClass parentClass; 4466 /** */ 4467 extern(C) void function(GtkAssistant* assistant, GtkWidget* page) prepare; 4468 /** */ 4469 extern(C) void function(GtkAssistant* assistant) apply; 4470 /** */ 4471 extern(C) void function(GtkAssistant* assistant) close; 4472 /** */ 4473 extern(C) void function(GtkAssistant* assistant) cancel; 4474 /** */ 4475 extern(C) void function() GtkReserved1; 4476 /** */ 4477 extern(C) void function() GtkReserved2; 4478 /** */ 4479 extern(C) void function() GtkReserved3; 4480 /** */ 4481 extern(C) void function() GtkReserved4; 4482 /** */ 4483 extern(C) void function() GtkReserved5; 4484 } 4485 4486 struct GtkAssistantPrivate; 4487 4488 struct GtkBin 4489 { 4490 GtkContainer container; 4491 GtkBinPrivate* priv; 4492 } 4493 4494 struct GtkBinClass 4495 { 4496 /** 4497 * The parent class. 4498 */ 4499 GtkContainerClass parentClass; 4500 /** */ 4501 extern(C) void function() GtkReserved1; 4502 /** */ 4503 extern(C) void function() GtkReserved2; 4504 /** */ 4505 extern(C) void function() GtkReserved3; 4506 /** */ 4507 extern(C) void function() GtkReserved4; 4508 } 4509 4510 struct GtkBinPrivate; 4511 4512 /** 4513 * A #GtkBindingArg holds the data associated with 4514 * an argument for a key binding signal emission as 4515 * stored in #GtkBindingSignal. 4516 */ 4517 struct GtkBindingArg 4518 { 4519 /** 4520 * implementation detail 4521 */ 4522 GType argType; 4523 union D 4524 { 4525 glong longData; 4526 double doubleData; 4527 char* stringData; 4528 } 4529 D d; 4530 } 4531 4532 /** 4533 * Each key binding element of a binding sets binding list is 4534 * represented by a GtkBindingEntry. 4535 */ 4536 struct GtkBindingEntry 4537 { 4538 /** 4539 * key value to match 4540 */ 4541 uint keyval; 4542 /** 4543 * key modifiers to match 4544 */ 4545 GdkModifierType modifiers; 4546 /** 4547 * binding set this entry belongs to 4548 */ 4549 GtkBindingSet* bindingSet; 4550 import std.bitmanip: bitfields; 4551 mixin(bitfields!( 4552 uint, "destroyed", 1, 4553 uint, "inEmission", 1, 4554 uint, "marksUnbound", 1, 4555 uint, "", 29 4556 )); 4557 /** 4558 * linked list of entries maintained by binding set 4559 */ 4560 GtkBindingEntry* setNext; 4561 /** 4562 * implementation detail 4563 */ 4564 GtkBindingEntry* hashNext; 4565 /** 4566 * action signals of this entry 4567 */ 4568 GtkBindingSignal* signals; 4569 } 4570 4571 struct GtkBindingSet 4572 { 4573 /** 4574 * unique name of this binding set 4575 */ 4576 char* setName; 4577 /** 4578 * unused 4579 */ 4580 int priority; 4581 /** 4582 * unused 4583 */ 4584 GSList* widgetPathPspecs; 4585 /** 4586 * unused 4587 */ 4588 GSList* widgetClassPspecs; 4589 /** 4590 * unused 4591 */ 4592 GSList* classBranchPspecs; 4593 /** 4594 * the key binding entries in this binding set 4595 */ 4596 GtkBindingEntry* entries; 4597 /** 4598 * implementation detail 4599 */ 4600 GtkBindingEntry* current; 4601 import std.bitmanip: bitfields; 4602 mixin(bitfields!( 4603 uint, "parsed", 1, 4604 uint, "", 31 4605 )); 4606 } 4607 4608 /** 4609 * A GtkBindingSignal stores the necessary information to 4610 * activate a widget in response to a key press via a signal 4611 * emission. 4612 */ 4613 struct GtkBindingSignal 4614 { 4615 /** 4616 * implementation detail 4617 */ 4618 GtkBindingSignal* next; 4619 /** 4620 * the action signal to be emitted 4621 */ 4622 char* signalName; 4623 /** 4624 * number of arguments specified for the signal 4625 */ 4626 uint nArgs; 4627 /** 4628 * the arguments specified for the signal 4629 */ 4630 GtkBindingArg* args; 4631 } 4632 4633 struct GtkBooleanCellAccessible 4634 { 4635 GtkRendererCellAccessible parent; 4636 GtkBooleanCellAccessiblePrivate* priv; 4637 } 4638 4639 struct GtkBooleanCellAccessibleClass 4640 { 4641 GtkRendererCellAccessibleClass parentClass; 4642 } 4643 4644 struct GtkBooleanCellAccessiblePrivate; 4645 4646 struct GtkBorder 4647 { 4648 /** 4649 * The width of the left border 4650 */ 4651 short left; 4652 /** 4653 * The width of the right border 4654 */ 4655 short right; 4656 /** 4657 * The width of the top border 4658 */ 4659 short top; 4660 /** 4661 * The width of the bottom border 4662 */ 4663 short bottom; 4664 } 4665 4666 struct GtkBox 4667 { 4668 GtkContainer container; 4669 GtkBoxPrivate* priv; 4670 } 4671 4672 struct GtkBoxClass 4673 { 4674 /** 4675 * The parent class. 4676 */ 4677 GtkContainerClass parentClass; 4678 /** */ 4679 extern(C) void function() GtkReserved1; 4680 /** */ 4681 extern(C) void function() GtkReserved2; 4682 /** */ 4683 extern(C) void function() GtkReserved3; 4684 /** */ 4685 extern(C) void function() GtkReserved4; 4686 } 4687 4688 struct GtkBoxPrivate; 4689 4690 struct GtkBuildable; 4691 4692 /** 4693 * The #GtkBuildableIface interface contains method that are 4694 * necessary to allow #GtkBuilder to construct an object from 4695 * a #GtkBuilder UI definition. 4696 */ 4697 struct GtkBuildableIface 4698 { 4699 /** 4700 * the parent class 4701 */ 4702 GTypeInterface gIface; 4703 /** */ 4704 extern(C) void function(GtkBuildable* buildable, const(char)* name) setName; 4705 /** 4706 * 4707 * Params: 4708 * buildable = a #GtkBuildable 4709 * Returns: the name set with gtk_buildable_set_name() 4710 */ 4711 extern(C) const(char)* function(GtkBuildable* buildable) getName; 4712 /** */ 4713 extern(C) void function(GtkBuildable* buildable, GtkBuilder* builder, GObject* child, const(char)* type) addChild; 4714 /** */ 4715 extern(C) void function(GtkBuildable* buildable, GtkBuilder* builder, const(char)* name, GValue* value) setBuildableProperty; 4716 /** 4717 * 4718 * Params: 4719 * buildable = A #GtkBuildable 4720 * builder = #GtkBuilder used to construct this object 4721 * name = name of child to construct 4722 * Returns: the constructed child 4723 */ 4724 extern(C) GObject* function(GtkBuildable* buildable, GtkBuilder* builder, const(char)* name) constructChild; 4725 /** 4726 * 4727 * Params: 4728 * buildable = a #GtkBuildable 4729 * builder = a #GtkBuilder used to construct this object 4730 * child = child object or %NULL for non-child tags 4731 * tagname = name of tag 4732 * parser = a #GMarkupParser to fill in 4733 * data = return location for user data that will be passed in 4734 * to parser functions 4735 * Returns: %TRUE if a object has a custom implementation, %FALSE 4736 * if it doesn't. 4737 */ 4738 extern(C) int function(GtkBuildable* buildable, GtkBuilder* builder, GObject* child, const(char)* tagname, GMarkupParser* parser, void** data) customTagStart; 4739 /** */ 4740 extern(C) void function(GtkBuildable* buildable, GtkBuilder* builder, GObject* child, const(char)* tagname, void** data) customTagEnd; 4741 /** */ 4742 extern(C) void function(GtkBuildable* buildable, GtkBuilder* builder, GObject* child, const(char)* tagname, void* data) customFinished; 4743 /** */ 4744 extern(C) void function(GtkBuildable* buildable, GtkBuilder* builder) parserFinished; 4745 /** 4746 * 4747 * Params: 4748 * buildable = a #GtkBuildable 4749 * builder = a #GtkBuilder 4750 * childname = name of child 4751 * Returns: the internal child of the buildable object 4752 */ 4753 extern(C) GObject* function(GtkBuildable* buildable, GtkBuilder* builder, const(char)* childname) getInternalChild; 4754 } 4755 4756 struct GtkBuilder 4757 { 4758 GObject parentInstance; 4759 GtkBuilderPrivate* priv; 4760 } 4761 4762 struct GtkBuilderClass 4763 { 4764 GObjectClass parentClass; 4765 /** 4766 * 4767 * Params: 4768 * builder = a #GtkBuilder 4769 * typeName = type name to lookup 4770 * Returns: the #GType found for @type_name or #G_TYPE_INVALID 4771 * if no type was found 4772 */ 4773 extern(C) GType function(GtkBuilder* builder, const(char)* typeName) getTypeFromName; 4774 /** */ 4775 extern(C) void function() GtkReserved1; 4776 /** */ 4777 extern(C) void function() GtkReserved2; 4778 /** */ 4779 extern(C) void function() GtkReserved3; 4780 /** */ 4781 extern(C) void function() GtkReserved4; 4782 /** */ 4783 extern(C) void function() GtkReserved5; 4784 /** */ 4785 extern(C) void function() GtkReserved6; 4786 /** */ 4787 extern(C) void function() GtkReserved7; 4788 /** */ 4789 extern(C) void function() GtkReserved8; 4790 } 4791 4792 struct GtkBuilderPrivate; 4793 4794 struct GtkButton 4795 { 4796 GtkBin bin; 4797 GtkButtonPrivate* priv; 4798 } 4799 4800 struct GtkButtonAccessible 4801 { 4802 GtkContainerAccessible parent; 4803 GtkButtonAccessiblePrivate* priv; 4804 } 4805 4806 struct GtkButtonAccessibleClass 4807 { 4808 GtkContainerAccessibleClass parentClass; 4809 } 4810 4811 struct GtkButtonAccessiblePrivate; 4812 4813 struct GtkButtonBox 4814 { 4815 GtkBox box; 4816 GtkButtonBoxPrivate* priv; 4817 } 4818 4819 struct GtkButtonBoxClass 4820 { 4821 /** 4822 * The parent class. 4823 */ 4824 GtkBoxClass parentClass; 4825 /** */ 4826 extern(C) void function() GtkReserved1; 4827 /** */ 4828 extern(C) void function() GtkReserved2; 4829 /** */ 4830 extern(C) void function() GtkReserved3; 4831 /** */ 4832 extern(C) void function() GtkReserved4; 4833 } 4834 4835 struct GtkButtonBoxPrivate; 4836 4837 struct GtkButtonClass 4838 { 4839 /** 4840 * The parent class. 4841 */ 4842 GtkBinClass parentClass; 4843 /** */ 4844 extern(C) void function(GtkButton* button) pressed; 4845 /** */ 4846 extern(C) void function(GtkButton* button) released; 4847 /** */ 4848 extern(C) void function(GtkButton* button) clicked; 4849 /** */ 4850 extern(C) void function(GtkButton* button) enter; 4851 /** */ 4852 extern(C) void function(GtkButton* button) leave; 4853 /** */ 4854 extern(C) void function(GtkButton* button) activate; 4855 /** */ 4856 extern(C) void function() GtkReserved1; 4857 /** */ 4858 extern(C) void function() GtkReserved2; 4859 /** */ 4860 extern(C) void function() GtkReserved3; 4861 /** */ 4862 extern(C) void function() GtkReserved4; 4863 } 4864 4865 struct GtkButtonPrivate; 4866 4867 struct GtkCalendar 4868 { 4869 GtkWidget widget; 4870 GtkCalendarPrivate* priv; 4871 } 4872 4873 struct GtkCalendarClass 4874 { 4875 GtkWidgetClass parentClass; 4876 /** */ 4877 extern(C) void function(GtkCalendar* calendar) monthChanged; 4878 /** */ 4879 extern(C) void function(GtkCalendar* calendar) daySelected; 4880 /** */ 4881 extern(C) void function(GtkCalendar* calendar) daySelectedDoubleClick; 4882 /** */ 4883 extern(C) void function(GtkCalendar* calendar) prevMonth; 4884 /** */ 4885 extern(C) void function(GtkCalendar* calendar) nextMonth; 4886 /** */ 4887 extern(C) void function(GtkCalendar* calendar) prevYear; 4888 /** */ 4889 extern(C) void function(GtkCalendar* calendar) nextYear; 4890 /** */ 4891 extern(C) void function() GtkReserved1; 4892 /** */ 4893 extern(C) void function() GtkReserved2; 4894 /** */ 4895 extern(C) void function() GtkReserved3; 4896 /** */ 4897 extern(C) void function() GtkReserved4; 4898 } 4899 4900 struct GtkCalendarPrivate; 4901 4902 struct GtkCellAccessible 4903 { 4904 GtkAccessible parent; 4905 GtkCellAccessiblePrivate* priv; 4906 } 4907 4908 struct GtkCellAccessibleClass 4909 { 4910 GtkAccessibleClass parentClass; 4911 /** */ 4912 extern(C) void function(GtkCellAccessible* cell, int emitSignal) updateCache; 4913 } 4914 4915 struct GtkCellAccessibleParent; 4916 4917 struct GtkCellAccessibleParentIface 4918 { 4919 GTypeInterface parent; 4920 /** */ 4921 extern(C) void function(GtkCellAccessibleParent* parent, GtkCellAccessible* cell, int* x, int* y, int* width, int* height, AtkCoordType coordType) getCellExtents; 4922 /** */ 4923 extern(C) void function(GtkCellAccessibleParent* parent, GtkCellAccessible* cell, GdkRectangle* cellRect) getCellArea; 4924 /** */ 4925 extern(C) int function(GtkCellAccessibleParent* parent, GtkCellAccessible* cell) grabFocus; 4926 /** */ 4927 extern(C) int function(GtkCellAccessibleParent* parent, GtkCellAccessible* cell) getChildIndex; 4928 /** */ 4929 extern(C) GtkCellRendererState function(GtkCellAccessibleParent* parent, GtkCellAccessible* cell) getRendererState; 4930 /** */ 4931 extern(C) void function(GtkCellAccessibleParent* parent, GtkCellAccessible* cell) expandCollapse; 4932 /** */ 4933 extern(C) void function(GtkCellAccessibleParent* parent, GtkCellAccessible* cell) activate; 4934 /** */ 4935 extern(C) void function(GtkCellAccessibleParent* parent, GtkCellAccessible* cell) edit; 4936 /** */ 4937 extern(C) void function(GtkCellAccessibleParent* parent, GtkCellAccessible* cell, AtkRelationSet* relationset) updateRelationset; 4938 } 4939 4940 struct GtkCellAccessiblePrivate; 4941 4942 struct GtkCellArea 4943 { 4944 GObject parentInstance; 4945 GtkCellAreaPrivate* priv; 4946 } 4947 4948 struct GtkCellAreaBox 4949 { 4950 GtkCellArea parentInstance; 4951 GtkCellAreaBoxPrivate* priv; 4952 } 4953 4954 struct GtkCellAreaBoxClass 4955 { 4956 GtkCellAreaClass parentClass; 4957 /** */ 4958 extern(C) void function() GtkReserved1; 4959 /** */ 4960 extern(C) void function() GtkReserved2; 4961 /** */ 4962 extern(C) void function() GtkReserved3; 4963 /** */ 4964 extern(C) void function() GtkReserved4; 4965 } 4966 4967 struct GtkCellAreaBoxPrivate; 4968 4969 struct GtkCellAreaClass 4970 { 4971 GObjectClass parentClass; 4972 /** */ 4973 extern(C) void function(GtkCellArea* area, GtkCellRenderer* renderer) add; 4974 /** */ 4975 extern(C) void function(GtkCellArea* area, GtkCellRenderer* renderer) remove; 4976 /** */ 4977 extern(C) void function(GtkCellArea* area, GtkCellCallback callback, void* callbackData) foreac; 4978 /** */ 4979 extern(C) void function(GtkCellArea* area, GtkCellAreaContext* context, GtkWidget* widget, GdkRectangle* cellArea, GdkRectangle* backgroundArea, GtkCellAllocCallback callback, void* callbackData) foreachAlloc; 4980 /** 4981 * 4982 * Params: 4983 * area = a #GtkCellArea 4984 * context = the #GtkCellAreaContext for this row of data. 4985 * widget = the #GtkWidget that @area is rendering to 4986 * event = the #GdkEvent to handle 4987 * cellArea = the @widget relative coordinates for @area 4988 * flags = the #GtkCellRendererState for @area in this row. 4989 * Returns: %TRUE if the event was handled by @area. 4990 */ 4991 extern(C) int function(GtkCellArea* area, GtkCellAreaContext* context, GtkWidget* widget, GdkEvent* event, GdkRectangle* cellArea, GtkCellRendererState flags) event; 4992 /** */ 4993 extern(C) void function(GtkCellArea* area, GtkCellAreaContext* context, GtkWidget* widget, cairo_t* cr, GdkRectangle* backgroundArea, GdkRectangle* cellArea, GtkCellRendererState flags, int paintFocus) render; 4994 /** */ 4995 extern(C) void function(GtkCellArea* area, GtkTreeModel* treeModel, GtkTreeIter* iter, int isExpander, int isExpanded) applyAttributes; 4996 /** 4997 * 4998 * Params: 4999 * area = a #GtkCellArea 5000 * Returns: a newly created #GtkCellAreaContext which can be used with @area. 5001 */ 5002 extern(C) GtkCellAreaContext* function(GtkCellArea* area) createContext; 5003 /** 5004 * 5005 * Params: 5006 * area = a #GtkCellArea 5007 * context = the #GtkCellAreaContext to copy 5008 * Returns: a newly created #GtkCellAreaContext copy of @context. 5009 */ 5010 extern(C) GtkCellAreaContext* function(GtkCellArea* area, GtkCellAreaContext* context) copyContext; 5011 /** 5012 * 5013 * Params: 5014 * area = a #GtkCellArea 5015 * Returns: The #GtkSizeRequestMode preferred by @area. 5016 */ 5017 extern(C) GtkSizeRequestMode function(GtkCellArea* area) getRequestMode; 5018 /** */ 5019 extern(C) void function(GtkCellArea* area, GtkCellAreaContext* context, GtkWidget* widget, int* minimumWidth, int* naturalWidth) getPreferredWidth; 5020 /** */ 5021 extern(C) void function(GtkCellArea* area, GtkCellAreaContext* context, GtkWidget* widget, int width, int* minimumHeight, int* naturalHeight) getPreferredHeightForWidth; 5022 /** */ 5023 extern(C) void function(GtkCellArea* area, GtkCellAreaContext* context, GtkWidget* widget, int* minimumHeight, int* naturalHeight) getPreferredHeight; 5024 /** */ 5025 extern(C) void function(GtkCellArea* area, GtkCellAreaContext* context, GtkWidget* widget, int height, int* minimumWidth, int* naturalWidth) getPreferredWidthForHeight; 5026 /** */ 5027 extern(C) void function(GtkCellArea* area, GtkCellRenderer* renderer, uint propertyId, GValue* value, GParamSpec* pspec) setCellProperty; 5028 /** */ 5029 extern(C) void function(GtkCellArea* area, GtkCellRenderer* renderer, uint propertyId, GValue* value, GParamSpec* pspec) getCellProperty; 5030 /** 5031 * 5032 * Params: 5033 * area = a #GtkCellArea 5034 * direction = the #GtkDirectionType 5035 * Returns: %TRUE if focus remains inside @area as a result of this call. 5036 */ 5037 extern(C) int function(GtkCellArea* area, GtkDirectionType direction) focus; 5038 /** 5039 * 5040 * Params: 5041 * area = a #GtkCellArea 5042 * Returns: whether @area can do anything when activated. 5043 */ 5044 extern(C) int function(GtkCellArea* area) isActivatable; 5045 /** 5046 * 5047 * Params: 5048 * area = a #GtkCellArea 5049 * context = the #GtkCellAreaContext in context with the current row data 5050 * widget = the #GtkWidget that @area is rendering on 5051 * cellArea = the size and location of @area relative to @widget’s allocation 5052 * flags = the #GtkCellRendererState flags for @area for this row of data. 5053 * editOnly = if %TRUE then only cell renderers that are %GTK_CELL_RENDERER_MODE_EDITABLE 5054 * will be activated. 5055 * Returns: Whether @area was successfully activated. 5056 */ 5057 extern(C) int function(GtkCellArea* area, GtkCellAreaContext* context, GtkWidget* widget, GdkRectangle* cellArea, GtkCellRendererState flags, int editOnly) activate; 5058 /** */ 5059 extern(C) void function() GtkReserved1; 5060 /** */ 5061 extern(C) void function() GtkReserved2; 5062 /** */ 5063 extern(C) void function() GtkReserved3; 5064 /** */ 5065 extern(C) void function() GtkReserved4; 5066 /** */ 5067 extern(C) void function() GtkReserved5; 5068 /** */ 5069 extern(C) void function() GtkReserved6; 5070 /** */ 5071 extern(C) void function() GtkReserved7; 5072 /** */ 5073 extern(C) void function() GtkReserved8; 5074 } 5075 5076 struct GtkCellAreaContext 5077 { 5078 GObject parentInstance; 5079 GtkCellAreaContextPrivate* priv; 5080 } 5081 5082 struct GtkCellAreaContextClass 5083 { 5084 GObjectClass parentClass; 5085 /** */ 5086 extern(C) void function(GtkCellAreaContext* context, int width, int height) allocate; 5087 /** */ 5088 extern(C) void function(GtkCellAreaContext* context) reset; 5089 /** */ 5090 extern(C) void function(GtkCellAreaContext* context, int width, int* minimumHeight, int* naturalHeight) getPreferredHeightForWidth; 5091 /** */ 5092 extern(C) void function(GtkCellAreaContext* context, int height, int* minimumWidth, int* naturalWidth) getPreferredWidthForHeight; 5093 /** */ 5094 extern(C) void function() GtkReserved1; 5095 /** */ 5096 extern(C) void function() GtkReserved2; 5097 /** */ 5098 extern(C) void function() GtkReserved3; 5099 /** */ 5100 extern(C) void function() GtkReserved4; 5101 /** */ 5102 extern(C) void function() GtkReserved5; 5103 /** */ 5104 extern(C) void function() GtkReserved6; 5105 } 5106 5107 struct GtkCellAreaContextPrivate; 5108 5109 struct GtkCellAreaPrivate; 5110 5111 struct GtkCellEditable; 5112 5113 struct GtkCellEditableIface 5114 { 5115 GTypeInterface gIface; 5116 /** */ 5117 extern(C) void function(GtkCellEditable* cellEditable) editingDone; 5118 /** */ 5119 extern(C) void function(GtkCellEditable* cellEditable) removeWidget; 5120 /** */ 5121 extern(C) void function(GtkCellEditable* cellEditable, GdkEvent* event) startEditing; 5122 } 5123 5124 struct GtkCellLayout; 5125 5126 struct GtkCellLayoutIface 5127 { 5128 GTypeInterface gIface; 5129 /** */ 5130 extern(C) void function(GtkCellLayout* cellLayout, GtkCellRenderer* cell, int expand) packStart; 5131 /** */ 5132 extern(C) void function(GtkCellLayout* cellLayout, GtkCellRenderer* cell, int expand) packEnd; 5133 /** */ 5134 extern(C) void function(GtkCellLayout* cellLayout) clear; 5135 /** */ 5136 extern(C) void function(GtkCellLayout* cellLayout, GtkCellRenderer* cell, const(char)* attribute, int column) addAttribute; 5137 /** */ 5138 extern(C) void function(GtkCellLayout* cellLayout, GtkCellRenderer* cell, GtkCellLayoutDataFunc func, void* funcData, GDestroyNotify destroy) setCellDataFunc; 5139 /** */ 5140 extern(C) void function(GtkCellLayout* cellLayout, GtkCellRenderer* cell) clearAttributes; 5141 /** */ 5142 extern(C) void function(GtkCellLayout* cellLayout, GtkCellRenderer* cell, int position) reorder; 5143 /** 5144 * 5145 * Params: 5146 * cellLayout = a #GtkCellLayout 5147 * Returns: a list of cell renderers. The list, but not the renderers has 5148 * been newly allocated and should be freed with g_list_free() 5149 * when no longer needed. 5150 */ 5151 extern(C) GList* function(GtkCellLayout* cellLayout) getCells; 5152 /** 5153 * 5154 * Params: 5155 * cellLayout = a #GtkCellLayout 5156 * Returns: the cell area used by @cell_layout, 5157 * or %NULL in case no cell area is used. 5158 */ 5159 extern(C) GtkCellArea* function(GtkCellLayout* cellLayout) getArea; 5160 } 5161 5162 struct GtkCellRenderer 5163 { 5164 GObject parentInstance; 5165 GtkCellRendererPrivate* priv; 5166 } 5167 5168 struct GtkCellRendererAccel 5169 { 5170 GtkCellRendererText parent; 5171 GtkCellRendererAccelPrivate* priv; 5172 } 5173 5174 struct GtkCellRendererAccelClass 5175 { 5176 GtkCellRendererTextClass parentClass; 5177 /** */ 5178 extern(C) void function(GtkCellRendererAccel* accel, const(char)* pathString, uint accelKey, GdkModifierType accelMods, uint hardwareKeycode) accelEdited; 5179 /** */ 5180 extern(C) void function(GtkCellRendererAccel* accel, const(char)* pathString) accelCleared; 5181 /** */ 5182 extern(C) void function() GtkReserved0; 5183 /** */ 5184 extern(C) void function() GtkReserved1; 5185 /** */ 5186 extern(C) void function() GtkReserved2; 5187 /** */ 5188 extern(C) void function() GtkReserved3; 5189 /** */ 5190 extern(C) void function() GtkReserved4; 5191 } 5192 5193 struct GtkCellRendererAccelPrivate; 5194 5195 struct GtkCellRendererClass 5196 { 5197 GObjectClass parentClass; 5198 /** 5199 * 5200 * Params: 5201 * cell = a #GtkCellRenderer instance 5202 * Returns: The #GtkSizeRequestMode preferred by this renderer. 5203 */ 5204 extern(C) GtkSizeRequestMode function(GtkCellRenderer* cell) getRequestMode; 5205 /** */ 5206 extern(C) void function(GtkCellRenderer* cell, GtkWidget* widget, int* minimumSize, int* naturalSize) getPreferredWidth; 5207 /** */ 5208 extern(C) void function(GtkCellRenderer* cell, GtkWidget* widget, int width, int* minimumHeight, int* naturalHeight) getPreferredHeightForWidth; 5209 /** */ 5210 extern(C) void function(GtkCellRenderer* cell, GtkWidget* widget, int* minimumSize, int* naturalSize) getPreferredHeight; 5211 /** */ 5212 extern(C) void function(GtkCellRenderer* cell, GtkWidget* widget, int height, int* minimumWidth, int* naturalWidth) getPreferredWidthForHeight; 5213 /** */ 5214 extern(C) void function(GtkCellRenderer* cell, GtkWidget* widget, GtkCellRendererState flags, GdkRectangle* cellArea, GdkRectangle* alignedArea) getAlignedArea; 5215 /** */ 5216 extern(C) void function(GtkCellRenderer* cell, GtkWidget* widget, GdkRectangle* cellArea, int* xOffset, int* yOffset, int* width, int* height) getSize; 5217 /** */ 5218 extern(C) void function(GtkCellRenderer* cell, cairo_t* cr, GtkWidget* widget, GdkRectangle* backgroundArea, GdkRectangle* cellArea, GtkCellRendererState flags) render; 5219 /** 5220 * 5221 * Params: 5222 * cell = a #GtkCellRenderer 5223 * event = a #GdkEvent 5224 * widget = widget that received the event 5225 * path = widget-dependent string representation of the event location; 5226 * e.g. for #GtkTreeView, a string representation of #GtkTreePath 5227 * backgroundArea = background area as passed to gtk_cell_renderer_render() 5228 * cellArea = cell area as passed to gtk_cell_renderer_render() 5229 * flags = render flags 5230 * Returns: %TRUE if the event was consumed/handled 5231 */ 5232 extern(C) int function(GtkCellRenderer* cell, GdkEvent* event, GtkWidget* widget, const(char)* path, GdkRectangle* backgroundArea, GdkRectangle* cellArea, GtkCellRendererState flags) activate; 5233 /** 5234 * 5235 * Params: 5236 * cell = a #GtkCellRenderer 5237 * event = a #GdkEvent 5238 * widget = widget that received the event 5239 * path = widget-dependent string representation of the event location; 5240 * e.g. for #GtkTreeView, a string representation of #GtkTreePath 5241 * backgroundArea = background area as passed to gtk_cell_renderer_render() 5242 * cellArea = cell area as passed to gtk_cell_renderer_render() 5243 * flags = render flags 5244 * Returns: A new #GtkCellEditable, or %NULL 5245 */ 5246 extern(C) GtkCellEditable* function(GtkCellRenderer* cell, GdkEvent* event, GtkWidget* widget, const(char)* path, GdkRectangle* backgroundArea, GdkRectangle* cellArea, GtkCellRendererState flags) startEditing; 5247 /** */ 5248 extern(C) void function(GtkCellRenderer* cell) editingCanceled; 5249 /** */ 5250 extern(C) void function(GtkCellRenderer* cell, GtkCellEditable* editable, const(char)* path) editingStarted; 5251 GtkCellRendererClassPrivate* priv; 5252 /** */ 5253 extern(C) void function() GtkReserved2; 5254 /** */ 5255 extern(C) void function() GtkReserved3; 5256 /** */ 5257 extern(C) void function() GtkReserved4; 5258 } 5259 5260 struct GtkCellRendererClassPrivate; 5261 5262 struct GtkCellRendererCombo 5263 { 5264 GtkCellRendererText parent; 5265 GtkCellRendererComboPrivate* priv; 5266 } 5267 5268 struct GtkCellRendererComboClass 5269 { 5270 GtkCellRendererTextClass parent; 5271 /** */ 5272 extern(C) void function() GtkReserved1; 5273 /** */ 5274 extern(C) void function() GtkReserved2; 5275 /** */ 5276 extern(C) void function() GtkReserved3; 5277 /** */ 5278 extern(C) void function() GtkReserved4; 5279 } 5280 5281 struct GtkCellRendererComboPrivate; 5282 5283 struct GtkCellRendererPixbuf 5284 { 5285 GtkCellRenderer parent; 5286 GtkCellRendererPixbufPrivate* priv; 5287 } 5288 5289 struct GtkCellRendererPixbufClass 5290 { 5291 GtkCellRendererClass parentClass; 5292 /** */ 5293 extern(C) void function() GtkReserved1; 5294 /** */ 5295 extern(C) void function() GtkReserved2; 5296 /** */ 5297 extern(C) void function() GtkReserved3; 5298 /** */ 5299 extern(C) void function() GtkReserved4; 5300 } 5301 5302 struct GtkCellRendererPixbufPrivate; 5303 5304 struct GtkCellRendererPrivate; 5305 5306 struct GtkCellRendererProgress 5307 { 5308 GtkCellRenderer parentInstance; 5309 GtkCellRendererProgressPrivate* priv; 5310 } 5311 5312 struct GtkCellRendererProgressClass 5313 { 5314 GtkCellRendererClass parentClass; 5315 /** */ 5316 extern(C) void function() GtkReserved1; 5317 /** */ 5318 extern(C) void function() GtkReserved2; 5319 /** */ 5320 extern(C) void function() GtkReserved3; 5321 /** */ 5322 extern(C) void function() GtkReserved4; 5323 } 5324 5325 struct GtkCellRendererProgressPrivate; 5326 5327 struct GtkCellRendererSpin 5328 { 5329 GtkCellRendererText parent; 5330 GtkCellRendererSpinPrivate* priv; 5331 } 5332 5333 struct GtkCellRendererSpinClass 5334 { 5335 GtkCellRendererTextClass parent; 5336 /** */ 5337 extern(C) void function() GtkReserved1; 5338 /** */ 5339 extern(C) void function() GtkReserved2; 5340 /** */ 5341 extern(C) void function() GtkReserved3; 5342 /** */ 5343 extern(C) void function() GtkReserved4; 5344 } 5345 5346 struct GtkCellRendererSpinPrivate; 5347 5348 struct GtkCellRendererSpinner 5349 { 5350 GtkCellRenderer parent; 5351 GtkCellRendererSpinnerPrivate* priv; 5352 } 5353 5354 struct GtkCellRendererSpinnerClass 5355 { 5356 GtkCellRendererClass parentClass; 5357 /** */ 5358 extern(C) void function() GtkReserved1; 5359 /** */ 5360 extern(C) void function() GtkReserved2; 5361 /** */ 5362 extern(C) void function() GtkReserved3; 5363 /** */ 5364 extern(C) void function() GtkReserved4; 5365 } 5366 5367 struct GtkCellRendererSpinnerPrivate; 5368 5369 struct GtkCellRendererText 5370 { 5371 GtkCellRenderer parent; 5372 GtkCellRendererTextPrivate* priv; 5373 } 5374 5375 struct GtkCellRendererTextClass 5376 { 5377 GtkCellRendererClass parentClass; 5378 /** */ 5379 extern(C) void function(GtkCellRendererText* cellRendererText, const(char)* path, const(char)* newText) edited; 5380 /** */ 5381 extern(C) void function() GtkReserved1; 5382 /** */ 5383 extern(C) void function() GtkReserved2; 5384 /** */ 5385 extern(C) void function() GtkReserved3; 5386 /** */ 5387 extern(C) void function() GtkReserved4; 5388 } 5389 5390 struct GtkCellRendererTextPrivate; 5391 5392 struct GtkCellRendererToggle 5393 { 5394 GtkCellRenderer parent; 5395 GtkCellRendererTogglePrivate* priv; 5396 } 5397 5398 struct GtkCellRendererToggleClass 5399 { 5400 GtkCellRendererClass parentClass; 5401 /** */ 5402 extern(C) void function(GtkCellRendererToggle* cellRendererToggle, const(char)* path) toggled; 5403 /** */ 5404 extern(C) void function() GtkReserved1; 5405 /** */ 5406 extern(C) void function() GtkReserved2; 5407 /** */ 5408 extern(C) void function() GtkReserved3; 5409 /** */ 5410 extern(C) void function() GtkReserved4; 5411 } 5412 5413 struct GtkCellRendererTogglePrivate; 5414 5415 struct GtkCellView 5416 { 5417 GtkWidget parentInstance; 5418 GtkCellViewPrivate* priv; 5419 } 5420 5421 struct GtkCellViewClass 5422 { 5423 /** 5424 * The parent class. 5425 */ 5426 GtkWidgetClass parentClass; 5427 /** */ 5428 extern(C) void function() GtkReserved1; 5429 /** */ 5430 extern(C) void function() GtkReserved2; 5431 /** */ 5432 extern(C) void function() GtkReserved3; 5433 /** */ 5434 extern(C) void function() GtkReserved4; 5435 } 5436 5437 struct GtkCellViewPrivate; 5438 5439 struct GtkCheckButton 5440 { 5441 GtkToggleButton toggleButton; 5442 } 5443 5444 struct GtkCheckButtonClass 5445 { 5446 GtkToggleButtonClass parentClass; 5447 /** */ 5448 extern(C) void function(GtkCheckButton* checkButton, cairo_t* cr) drawIndicator; 5449 /** */ 5450 extern(C) void function() GtkReserved1; 5451 /** */ 5452 extern(C) void function() GtkReserved2; 5453 /** */ 5454 extern(C) void function() GtkReserved3; 5455 /** */ 5456 extern(C) void function() GtkReserved4; 5457 } 5458 5459 struct GtkCheckMenuItem 5460 { 5461 GtkMenuItem menuItem; 5462 GtkCheckMenuItemPrivate* priv; 5463 } 5464 5465 struct GtkCheckMenuItemAccessible 5466 { 5467 GtkMenuItemAccessible parent; 5468 GtkCheckMenuItemAccessiblePrivate* priv; 5469 } 5470 5471 struct GtkCheckMenuItemAccessibleClass 5472 { 5473 GtkMenuItemAccessibleClass parentClass; 5474 } 5475 5476 struct GtkCheckMenuItemAccessiblePrivate; 5477 5478 struct GtkCheckMenuItemClass 5479 { 5480 /** 5481 * The parent class. 5482 */ 5483 GtkMenuItemClass parentClass; 5484 /** */ 5485 extern(C) void function(GtkCheckMenuItem* checkMenuItem) toggled; 5486 /** */ 5487 extern(C) void function(GtkCheckMenuItem* checkMenuItem, cairo_t* cr) drawIndicator; 5488 /** */ 5489 extern(C) void function() GtkReserved1; 5490 /** */ 5491 extern(C) void function() GtkReserved2; 5492 /** */ 5493 extern(C) void function() GtkReserved3; 5494 /** */ 5495 extern(C) void function() GtkReserved4; 5496 } 5497 5498 struct GtkCheckMenuItemPrivate; 5499 5500 struct GtkClipboard; 5501 5502 struct GtkColorButton 5503 { 5504 GtkButton button; 5505 GtkColorButtonPrivate* priv; 5506 } 5507 5508 struct GtkColorButtonClass 5509 { 5510 GtkButtonClass parentClass; 5511 /** */ 5512 extern(C) void function(GtkColorButton* cp) colorSet; 5513 /** */ 5514 extern(C) void function() GtkReserved1; 5515 /** */ 5516 extern(C) void function() GtkReserved2; 5517 /** */ 5518 extern(C) void function() GtkReserved3; 5519 /** */ 5520 extern(C) void function() GtkReserved4; 5521 } 5522 5523 struct GtkColorButtonPrivate; 5524 5525 struct GtkColorChooser; 5526 5527 struct GtkColorChooserDialog 5528 { 5529 GtkDialog parentInstance; 5530 GtkColorChooserDialogPrivate* priv; 5531 } 5532 5533 struct GtkColorChooserDialogClass 5534 { 5535 GtkDialogClass parentClass; 5536 /** */ 5537 extern(C) void function() GtkReserved1; 5538 /** */ 5539 extern(C) void function() GtkReserved2; 5540 /** */ 5541 extern(C) void function() GtkReserved3; 5542 /** */ 5543 extern(C) void function() GtkReserved4; 5544 } 5545 5546 struct GtkColorChooserDialogPrivate; 5547 5548 struct GtkColorChooserInterface 5549 { 5550 GTypeInterface baseInterface; 5551 /** */ 5552 extern(C) void function(GtkColorChooser* chooser, GdkRGBA* color) getRgba; 5553 /** */ 5554 extern(C) void function(GtkColorChooser* chooser, GdkRGBA* color) setRgba; 5555 /** */ 5556 extern(C) void function(GtkColorChooser* chooser, GtkOrientation orientation, int colorsPerLine, int nColors, GdkRGBA* colors) addPalette; 5557 /** */ 5558 extern(C) void function(GtkColorChooser* chooser, GdkRGBA* color) colorActivated; 5559 void*[12] padding; 5560 } 5561 5562 struct GtkColorChooserWidget 5563 { 5564 GtkBox parentInstance; 5565 GtkColorChooserWidgetPrivate* priv; 5566 } 5567 5568 struct GtkColorChooserWidgetClass 5569 { 5570 /** 5571 * The parent class. 5572 */ 5573 GtkBoxClass parentClass; 5574 /** */ 5575 extern(C) void function() GtkReserved1; 5576 /** */ 5577 extern(C) void function() GtkReserved2; 5578 /** */ 5579 extern(C) void function() GtkReserved3; 5580 /** */ 5581 extern(C) void function() GtkReserved4; 5582 /** */ 5583 extern(C) void function() GtkReserved5; 5584 /** */ 5585 extern(C) void function() GtkReserved6; 5586 /** */ 5587 extern(C) void function() GtkReserved7; 5588 /** */ 5589 extern(C) void function() GtkReserved8; 5590 } 5591 5592 struct GtkColorChooserWidgetPrivate; 5593 5594 struct GtkColorSelection 5595 { 5596 GtkBox parentInstance; 5597 GtkColorSelectionPrivate* privateData; 5598 } 5599 5600 struct GtkColorSelectionClass 5601 { 5602 /** 5603 * The parent class. 5604 */ 5605 GtkBoxClass parentClass; 5606 /** */ 5607 extern(C) void function(GtkColorSelection* colorSelection) colorChanged; 5608 /** */ 5609 extern(C) void function() GtkReserved1; 5610 /** */ 5611 extern(C) void function() GtkReserved2; 5612 /** */ 5613 extern(C) void function() GtkReserved3; 5614 /** */ 5615 extern(C) void function() GtkReserved4; 5616 } 5617 5618 struct GtkColorSelectionDialog 5619 { 5620 GtkDialog parentInstance; 5621 GtkColorSelectionDialogPrivate* priv; 5622 } 5623 5624 struct GtkColorSelectionDialogClass 5625 { 5626 GtkDialogClass parentClass; 5627 /** */ 5628 extern(C) void function() GtkReserved1; 5629 /** */ 5630 extern(C) void function() GtkReserved2; 5631 /** */ 5632 extern(C) void function() GtkReserved3; 5633 /** */ 5634 extern(C) void function() GtkReserved4; 5635 } 5636 5637 struct GtkColorSelectionDialogPrivate; 5638 5639 struct GtkColorSelectionPrivate; 5640 5641 struct GtkComboBox 5642 { 5643 GtkBin parentInstance; 5644 GtkComboBoxPrivate* priv; 5645 } 5646 5647 struct GtkComboBoxAccessible 5648 { 5649 GtkContainerAccessible parent; 5650 GtkComboBoxAccessiblePrivate* priv; 5651 } 5652 5653 struct GtkComboBoxAccessibleClass 5654 { 5655 GtkContainerAccessibleClass parentClass; 5656 } 5657 5658 struct GtkComboBoxAccessiblePrivate; 5659 5660 struct GtkComboBoxClass 5661 { 5662 /** 5663 * The parent class. 5664 */ 5665 GtkBinClass parentClass; 5666 /** */ 5667 extern(C) void function(GtkComboBox* comboBox) changed; 5668 /** */ 5669 extern(C) char* function(GtkComboBox* comboBox, const(char)* path) formatEntryText; 5670 /** */ 5671 extern(C) void function() GtkReserved1; 5672 /** */ 5673 extern(C) void function() GtkReserved2; 5674 /** */ 5675 extern(C) void function() GtkReserved3; 5676 } 5677 5678 struct GtkComboBoxPrivate; 5679 5680 struct GtkComboBoxText 5681 { 5682 GtkComboBox parentInstance; 5683 GtkComboBoxTextPrivate* priv; 5684 } 5685 5686 struct GtkComboBoxTextClass 5687 { 5688 GtkComboBoxClass parentClass; 5689 /** */ 5690 extern(C) void function() GtkReserved1; 5691 /** */ 5692 extern(C) void function() GtkReserved2; 5693 /** */ 5694 extern(C) void function() GtkReserved3; 5695 /** */ 5696 extern(C) void function() GtkReserved4; 5697 } 5698 5699 struct GtkComboBoxTextPrivate; 5700 5701 struct GtkContainer 5702 { 5703 GtkWidget widget; 5704 GtkContainerPrivate* priv; 5705 } 5706 5707 struct GtkContainerAccessible 5708 { 5709 GtkWidgetAccessible parent; 5710 GtkContainerAccessiblePrivate* priv; 5711 } 5712 5713 struct GtkContainerAccessibleClass 5714 { 5715 GtkWidgetAccessibleClass parentClass; 5716 /** */ 5717 extern(C) int function(GtkContainer* container, GtkWidget* widget, void* data) addGtk; 5718 /** */ 5719 extern(C) int function(GtkContainer* container, GtkWidget* widget, void* data) removeGtk; 5720 } 5721 5722 struct GtkContainerAccessiblePrivate; 5723 5724 struct GtkContainerCellAccessible 5725 { 5726 GtkCellAccessible parent; 5727 GtkContainerCellAccessiblePrivate* priv; 5728 } 5729 5730 struct GtkContainerCellAccessibleClass 5731 { 5732 GtkCellAccessibleClass parentClass; 5733 } 5734 5735 struct GtkContainerCellAccessiblePrivate; 5736 5737 struct GtkContainerClass 5738 { 5739 /** 5740 * The parent class. 5741 */ 5742 GtkWidgetClass parentClass; 5743 /** */ 5744 extern(C) void function(GtkContainer* container, GtkWidget* widget) add; 5745 /** */ 5746 extern(C) void function(GtkContainer* container, GtkWidget* widget) remove; 5747 /** */ 5748 extern(C) void function(GtkContainer* container) checkResize; 5749 /** */ 5750 extern(C) void function(GtkContainer* container, int includeInternals, GtkCallback callback, void* callbackData) forall; 5751 /** */ 5752 extern(C) void function(GtkContainer* container, GtkWidget* child) setFocusChild; 5753 /** 5754 * 5755 * Params: 5756 * container = a #GtkContainer 5757 * Returns: a #GType. 5758 */ 5759 extern(C) GType function(GtkContainer* container) childType; 5760 /** */ 5761 extern(C) char* function(GtkContainer* container, GtkWidget* child) compositeName; 5762 /** */ 5763 extern(C) void function(GtkContainer* container, GtkWidget* child, uint propertyId, GValue* value, GParamSpec* pspec) setChildProperty; 5764 /** */ 5765 extern(C) void function(GtkContainer* container, GtkWidget* child, uint propertyId, GValue* value, GParamSpec* pspec) getChildProperty; 5766 /** 5767 * 5768 * Params: 5769 * container = a #GtkContainer 5770 * child = a child of @container 5771 * Returns: A newly created #GtkWidgetPath 5772 */ 5773 extern(C) GtkWidgetPath* function(GtkContainer* container, GtkWidget* child) getPathForChild; 5774 import std.bitmanip: bitfields; 5775 mixin(bitfields!( 5776 uint, "HandleBorderWidth", 1, 5777 uint, "", 31 5778 )); 5779 /** */ 5780 extern(C) void function() GtkReserved1; 5781 /** */ 5782 extern(C) void function() GtkReserved2; 5783 /** */ 5784 extern(C) void function() GtkReserved3; 5785 /** */ 5786 extern(C) void function() GtkReserved4; 5787 /** */ 5788 extern(C) void function() GtkReserved5; 5789 /** */ 5790 extern(C) void function() GtkReserved6; 5791 /** */ 5792 extern(C) void function() GtkReserved7; 5793 /** */ 5794 extern(C) void function() GtkReserved8; 5795 } 5796 5797 struct GtkContainerPrivate; 5798 5799 struct GtkCssProvider 5800 { 5801 GObject parentInstance; 5802 GtkCssProviderPrivate* priv; 5803 } 5804 5805 struct GtkCssProviderClass 5806 { 5807 GObjectClass parentClass; 5808 /** */ 5809 extern(C) void function(GtkCssProvider* provider, GtkCssSection* section, GError* error) parsingError; 5810 /** */ 5811 extern(C) void function() GtkReserved2; 5812 /** */ 5813 extern(C) void function() GtkReserved3; 5814 /** */ 5815 extern(C) void function() GtkReserved4; 5816 } 5817 5818 struct GtkCssProviderPrivate; 5819 5820 struct GtkCssSection; 5821 5822 struct GtkDialog 5823 { 5824 GtkWindow window; 5825 GtkDialogPrivate* priv; 5826 } 5827 5828 struct GtkDialogClass 5829 { 5830 /** 5831 * The parent class. 5832 */ 5833 GtkWindowClass parentClass; 5834 /** */ 5835 extern(C) void function(GtkDialog* dialog, int responseId) response; 5836 /** */ 5837 extern(C) void function(GtkDialog* dialog) close; 5838 /** */ 5839 extern(C) void function() GtkReserved1; 5840 /** */ 5841 extern(C) void function() GtkReserved2; 5842 /** */ 5843 extern(C) void function() GtkReserved3; 5844 /** */ 5845 extern(C) void function() GtkReserved4; 5846 } 5847 5848 struct GtkDialogPrivate; 5849 5850 struct GtkDrawingArea 5851 { 5852 GtkWidget widget; 5853 void* dummy; 5854 } 5855 5856 struct GtkDrawingAreaClass 5857 { 5858 GtkWidgetClass parentClass; 5859 /** */ 5860 extern(C) void function() GtkReserved1; 5861 /** */ 5862 extern(C) void function() GtkReserved2; 5863 /** */ 5864 extern(C) void function() GtkReserved3; 5865 /** */ 5866 extern(C) void function() GtkReserved4; 5867 } 5868 5869 struct GtkEditable; 5870 5871 struct GtkEditableInterface 5872 { 5873 GTypeInterface baseIface; 5874 /** */ 5875 extern(C) void function(GtkEditable* editable, const(char)* newText, int newTextLength, int* position) insertText; 5876 /** */ 5877 extern(C) void function(GtkEditable* editable, int startPos, int endPos) deleteText; 5878 /** */ 5879 extern(C) void function(GtkEditable* editable) changed; 5880 /** */ 5881 extern(C) void function(GtkEditable* editable, const(char)* newText, int newTextLength, int* position) doInsertText; 5882 /** */ 5883 extern(C) void function(GtkEditable* editable, int startPos, int endPos) doDeleteText; 5884 /** 5885 * 5886 * Params: 5887 * editable = a #GtkEditable 5888 * startPos = start of text 5889 * endPos = end of text 5890 * Returns: a pointer to the contents of the widget as a 5891 * string. This string is allocated by the #GtkEditable 5892 * implementation and should be freed by the caller. 5893 */ 5894 extern(C) char* function(GtkEditable* editable, int startPos, int endPos) getChars; 5895 /** */ 5896 extern(C) void function(GtkEditable* editable, int startPos, int endPos) setSelectionBounds; 5897 /** 5898 * 5899 * Params: 5900 * editable = a #GtkEditable 5901 * startPos = location to store the starting position, or %NULL 5902 * endPos = location to store the end position, or %NULL 5903 * Returns: %TRUE if an area is selected, %FALSE otherwise 5904 */ 5905 extern(C) int function(GtkEditable* editable, int* startPos, int* endPos) getSelectionBounds; 5906 /** */ 5907 extern(C) void function(GtkEditable* editable, int position) setPosition; 5908 /** 5909 * 5910 * Params: 5911 * editable = a #GtkEditable 5912 * Returns: the cursor position 5913 */ 5914 extern(C) int function(GtkEditable* editable) getPosition; 5915 } 5916 5917 struct GtkEntry 5918 { 5919 GtkWidget parentInstance; 5920 GtkEntryPrivate* priv; 5921 } 5922 5923 struct GtkEntryAccessible 5924 { 5925 GtkWidgetAccessible parent; 5926 GtkEntryAccessiblePrivate* priv; 5927 } 5928 5929 struct GtkEntryAccessibleClass 5930 { 5931 GtkWidgetAccessibleClass parentClass; 5932 } 5933 5934 struct GtkEntryAccessiblePrivate; 5935 5936 struct GtkEntryBuffer 5937 { 5938 GObject parentInstance; 5939 GtkEntryBufferPrivate* priv; 5940 } 5941 5942 struct GtkEntryBufferClass 5943 { 5944 GObjectClass parentClass; 5945 /** */ 5946 extern(C) void function(GtkEntryBuffer* buffer, uint position, const(char)* chars, uint nChars) insertedText; 5947 /** */ 5948 extern(C) void function(GtkEntryBuffer* buffer, uint position, uint nChars) deletedText; 5949 /** */ 5950 extern(C) const(char)* function(GtkEntryBuffer* buffer, size_t* nBytes) getText; 5951 /** 5952 * 5953 * Params: 5954 * buffer = a #GtkEntryBuffer 5955 * Returns: The number of characters in the buffer. 5956 */ 5957 extern(C) uint function(GtkEntryBuffer* buffer) getLength; 5958 /** 5959 * 5960 * Params: 5961 * buffer = a #GtkEntryBuffer 5962 * position = the position at which to insert text. 5963 * chars = the text to insert into the buffer. 5964 * nChars = the length of the text in characters, or -1 5965 * Returns: The number of characters actually inserted. 5966 */ 5967 extern(C) uint function(GtkEntryBuffer* buffer, uint position, const(char)* chars, uint nChars) insertText; 5968 /** 5969 * 5970 * Params: 5971 * buffer = a #GtkEntryBuffer 5972 * position = position at which to delete text 5973 * nChars = number of characters to delete 5974 * Returns: The number of characters deleted. 5975 */ 5976 extern(C) uint function(GtkEntryBuffer* buffer, uint position, uint nChars) deleteText; 5977 /** */ 5978 extern(C) void function() GtkReserved1; 5979 /** */ 5980 extern(C) void function() GtkReserved2; 5981 /** */ 5982 extern(C) void function() GtkReserved3; 5983 /** */ 5984 extern(C) void function() GtkReserved4; 5985 /** */ 5986 extern(C) void function() GtkReserved5; 5987 /** */ 5988 extern(C) void function() GtkReserved6; 5989 /** */ 5990 extern(C) void function() GtkReserved7; 5991 /** */ 5992 extern(C) void function() GtkReserved8; 5993 } 5994 5995 struct GtkEntryBufferPrivate; 5996 5997 /** 5998 * Class structure for #GtkEntry. All virtual functions have a default 5999 * implementation. Derived classes may set the virtual function pointers for the 6000 * signal handlers to %NULL, but must keep @get_text_area_size and 6001 * @get_frame_size non-%NULL; either use the default implementation, or provide 6002 * a custom one. 6003 */ 6004 struct GtkEntryClass 6005 { 6006 /** 6007 * The parent class. 6008 */ 6009 GtkWidgetClass parentClass; 6010 /** */ 6011 extern(C) void function(GtkEntry* entry, GtkWidget* popup) populatePopup; 6012 /** */ 6013 extern(C) void function(GtkEntry* entry) activate; 6014 /** */ 6015 extern(C) void function(GtkEntry* entry, GtkMovementStep step, int count, int extendSelection) moveCursor; 6016 /** */ 6017 extern(C) void function(GtkEntry* entry, const(char)* str) insertAtCursor; 6018 /** */ 6019 extern(C) void function(GtkEntry* entry, GtkDeleteType type, int count) deleteFromCursor; 6020 /** */ 6021 extern(C) void function(GtkEntry* entry) backspace; 6022 /** */ 6023 extern(C) void function(GtkEntry* entry) cutClipboard; 6024 /** */ 6025 extern(C) void function(GtkEntry* entry) copyClipboard; 6026 /** */ 6027 extern(C) void function(GtkEntry* entry) pasteClipboard; 6028 /** */ 6029 extern(C) void function(GtkEntry* entry) toggleOverwrite; 6030 /** */ 6031 extern(C) void function(GtkEntry* entry, int* x, int* y, int* width, int* height) getTextAreaSize; 6032 /** */ 6033 extern(C) void function(GtkEntry* entry, int* x, int* y, int* width, int* height) getFrameSize; 6034 /** */ 6035 extern(C) void function() GtkReserved1; 6036 /** */ 6037 extern(C) void function() GtkReserved2; 6038 /** */ 6039 extern(C) void function() GtkReserved3; 6040 /** */ 6041 extern(C) void function() GtkReserved4; 6042 /** */ 6043 extern(C) void function() GtkReserved5; 6044 /** */ 6045 extern(C) void function() GtkReserved6; 6046 /** */ 6047 extern(C) void function() GtkReserved7; 6048 } 6049 6050 struct GtkEntryCompletion 6051 { 6052 GObject parentInstance; 6053 GtkEntryCompletionPrivate* priv; 6054 } 6055 6056 struct GtkEntryCompletionClass 6057 { 6058 GObjectClass parentClass; 6059 /** */ 6060 extern(C) int function(GtkEntryCompletion* completion, GtkTreeModel* model, GtkTreeIter* iter) matchSelected; 6061 /** */ 6062 extern(C) void function(GtkEntryCompletion* completion, int index) actionActivated; 6063 /** */ 6064 extern(C) int function(GtkEntryCompletion* completion, const(char)* prefix) insertPrefix; 6065 /** */ 6066 extern(C) int function(GtkEntryCompletion* completion, GtkTreeModel* model, GtkTreeIter* iter) cursorOnMatch; 6067 /** */ 6068 extern(C) void function(GtkEntryCompletion* completion) noMatches; 6069 /** */ 6070 extern(C) void function() GtkReserved0; 6071 /** */ 6072 extern(C) void function() GtkReserved1; 6073 /** */ 6074 extern(C) void function() GtkReserved2; 6075 } 6076 6077 struct GtkEntryCompletionPrivate; 6078 6079 6080 struct GtkEntryPrivate; 6081 6082 struct GtkEventBox 6083 { 6084 GtkBin bin; 6085 GtkEventBoxPrivate* priv; 6086 } 6087 6088 struct GtkEventBoxClass 6089 { 6090 /** 6091 * The parent class. 6092 */ 6093 GtkBinClass parentClass; 6094 /** */ 6095 extern(C) void function() GtkReserved1; 6096 /** */ 6097 extern(C) void function() GtkReserved2; 6098 /** */ 6099 extern(C) void function() GtkReserved3; 6100 /** */ 6101 extern(C) void function() GtkReserved4; 6102 } 6103 6104 struct GtkEventBoxPrivate; 6105 6106 struct GtkEventController; 6107 6108 struct GtkEventControllerClass; 6109 6110 struct GtkExpander 6111 { 6112 GtkBin bin; 6113 GtkExpanderPrivate* priv; 6114 } 6115 6116 struct GtkExpanderAccessible 6117 { 6118 GtkContainerAccessible parent; 6119 GtkExpanderAccessiblePrivate* priv; 6120 } 6121 6122 struct GtkExpanderAccessibleClass 6123 { 6124 GtkContainerAccessibleClass parentClass; 6125 } 6126 6127 struct GtkExpanderAccessiblePrivate; 6128 6129 struct GtkExpanderClass 6130 { 6131 /** 6132 * The parent class. 6133 */ 6134 GtkBinClass parentClass; 6135 /** */ 6136 extern(C) void function(GtkExpander* expander) activate; 6137 /** */ 6138 extern(C) void function() GtkReserved1; 6139 /** */ 6140 extern(C) void function() GtkReserved2; 6141 /** */ 6142 extern(C) void function() GtkReserved3; 6143 /** */ 6144 extern(C) void function() GtkReserved4; 6145 } 6146 6147 struct GtkExpanderPrivate; 6148 6149 struct GtkFileChooser; 6150 6151 struct GtkFileChooserButton 6152 { 6153 GtkBox parent; 6154 GtkFileChooserButtonPrivate* priv; 6155 } 6156 6157 struct GtkFileChooserButtonClass 6158 { 6159 /** 6160 * The parent class. 6161 */ 6162 GtkBoxClass parentClass; 6163 /** */ 6164 extern(C) void function(GtkFileChooserButton* fc) fileSet; 6165 void* GtkReserved1; 6166 void* GtkReserved2; 6167 void* GtkReserved3; 6168 void* GtkReserved4; 6169 } 6170 6171 struct GtkFileChooserButtonPrivate; 6172 6173 struct GtkFileChooserDialog 6174 { 6175 GtkDialog parentInstance; 6176 GtkFileChooserDialogPrivate* priv; 6177 } 6178 6179 struct GtkFileChooserDialogClass 6180 { 6181 GtkDialogClass parentClass; 6182 /** */ 6183 extern(C) void function() GtkReserved1; 6184 /** */ 6185 extern(C) void function() GtkReserved2; 6186 /** */ 6187 extern(C) void function() GtkReserved3; 6188 /** */ 6189 extern(C) void function() GtkReserved4; 6190 } 6191 6192 struct GtkFileChooserDialogPrivate; 6193 6194 struct GtkFileChooserNative; 6195 6196 struct GtkFileChooserNativeClass 6197 { 6198 GtkNativeDialogClass parentClass; 6199 } 6200 6201 struct GtkFileChooserWidget 6202 { 6203 GtkBox parentInstance; 6204 GtkFileChooserWidgetPrivate* priv; 6205 } 6206 6207 struct GtkFileChooserWidgetClass 6208 { 6209 /** 6210 * The parent class. 6211 */ 6212 GtkBoxClass parentClass; 6213 /** */ 6214 extern(C) void function() GtkReserved1; 6215 /** */ 6216 extern(C) void function() GtkReserved2; 6217 /** */ 6218 extern(C) void function() GtkReserved3; 6219 /** */ 6220 extern(C) void function() GtkReserved4; 6221 } 6222 6223 struct GtkFileChooserWidgetPrivate; 6224 6225 struct GtkFileFilter; 6226 6227 /** 6228 * A #GtkFileFilterInfo-struct is used to pass information about the 6229 * tested file to gtk_file_filter_filter(). 6230 */ 6231 struct GtkFileFilterInfo 6232 { 6233 /** 6234 * Flags indicating which of the following fields need 6235 * are filled 6236 */ 6237 GtkFileFilterFlags contains; 6238 /** 6239 * the filename of the file being tested 6240 */ 6241 const(char)* filename; 6242 /** 6243 * the URI for the file being tested 6244 */ 6245 const(char)* uri; 6246 /** 6247 * the string that will be used to display the file 6248 * in the file chooser 6249 */ 6250 const(char)* displayName; 6251 /** 6252 * the mime type of the file 6253 */ 6254 const(char)* mimeType; 6255 } 6256 6257 struct GtkFixed 6258 { 6259 GtkContainer container; 6260 GtkFixedPrivate* priv; 6261 } 6262 6263 struct GtkFixedChild 6264 { 6265 GtkWidget* widget; 6266 int x; 6267 int y; 6268 } 6269 6270 struct GtkFixedClass 6271 { 6272 GtkContainerClass parentClass; 6273 /** */ 6274 extern(C) void function() GtkReserved1; 6275 /** */ 6276 extern(C) void function() GtkReserved2; 6277 /** */ 6278 extern(C) void function() GtkReserved3; 6279 /** */ 6280 extern(C) void function() GtkReserved4; 6281 } 6282 6283 struct GtkFixedPrivate; 6284 6285 struct GtkFlowBox 6286 { 6287 GtkContainer container; 6288 } 6289 6290 struct GtkFlowBoxAccessible 6291 { 6292 GtkContainerAccessible parent; 6293 GtkFlowBoxAccessiblePrivate* priv; 6294 } 6295 6296 struct GtkFlowBoxAccessibleClass 6297 { 6298 GtkContainerAccessibleClass parentClass; 6299 } 6300 6301 struct GtkFlowBoxAccessiblePrivate; 6302 6303 struct GtkFlowBoxChild 6304 { 6305 GtkBin parentInstance; 6306 } 6307 6308 struct GtkFlowBoxChildAccessible 6309 { 6310 GtkContainerAccessible parent; 6311 } 6312 6313 struct GtkFlowBoxChildAccessibleClass 6314 { 6315 GtkContainerAccessibleClass parentClass; 6316 } 6317 6318 struct GtkFlowBoxChildClass 6319 { 6320 GtkBinClass parentClass; 6321 /** */ 6322 extern(C) void function(GtkFlowBoxChild* child) activate; 6323 /** */ 6324 extern(C) void function() GtkReserved1; 6325 /** */ 6326 extern(C) void function() GtkReserved2; 6327 } 6328 6329 struct GtkFlowBoxClass 6330 { 6331 GtkContainerClass parentClass; 6332 /** */ 6333 extern(C) void function(GtkFlowBox* box, GtkFlowBoxChild* child) childActivated; 6334 /** */ 6335 extern(C) void function(GtkFlowBox* box) selectedChildrenChanged; 6336 /** */ 6337 extern(C) void function(GtkFlowBox* box) activateCursorChild; 6338 /** */ 6339 extern(C) void function(GtkFlowBox* box) toggleCursorChild; 6340 /** */ 6341 extern(C) int function(GtkFlowBox* box, GtkMovementStep step, int count) moveCursor; 6342 /** */ 6343 extern(C) void function(GtkFlowBox* box) selectAll; 6344 /** */ 6345 extern(C) void function(GtkFlowBox* box) unselectAll; 6346 /** */ 6347 extern(C) void function() GtkReserved1; 6348 /** */ 6349 extern(C) void function() GtkReserved2; 6350 /** */ 6351 extern(C) void function() GtkReserved3; 6352 /** */ 6353 extern(C) void function() GtkReserved4; 6354 /** */ 6355 extern(C) void function() GtkReserved5; 6356 /** */ 6357 extern(C) void function() GtkReserved6; 6358 } 6359 6360 struct GtkFontButton 6361 { 6362 GtkButton button; 6363 GtkFontButtonPrivate* priv; 6364 } 6365 6366 struct GtkFontButtonClass 6367 { 6368 GtkButtonClass parentClass; 6369 /** */ 6370 extern(C) void function(GtkFontButton* gfp) fontSet; 6371 /** */ 6372 extern(C) void function() GtkReserved1; 6373 /** */ 6374 extern(C) void function() GtkReserved2; 6375 /** */ 6376 extern(C) void function() GtkReserved3; 6377 /** */ 6378 extern(C) void function() GtkReserved4; 6379 } 6380 6381 struct GtkFontButtonPrivate; 6382 6383 struct GtkFontChooser; 6384 6385 struct GtkFontChooserDialog 6386 { 6387 GtkDialog parentInstance; 6388 GtkFontChooserDialogPrivate* priv; 6389 } 6390 6391 struct GtkFontChooserDialogClass 6392 { 6393 /** 6394 * The parent class. 6395 */ 6396 GtkDialogClass parentClass; 6397 /** */ 6398 extern(C) void function() GtkReserved1; 6399 /** */ 6400 extern(C) void function() GtkReserved2; 6401 /** */ 6402 extern(C) void function() GtkReserved3; 6403 /** */ 6404 extern(C) void function() GtkReserved4; 6405 } 6406 6407 struct GtkFontChooserDialogPrivate; 6408 6409 struct GtkFontChooserIface 6410 { 6411 GTypeInterface baseIface; 6412 /** 6413 * 6414 * Params: 6415 * fontchooser = a #GtkFontChooser 6416 * Returns: A #PangoFontFamily representing the 6417 * selected font family, or %NULL. The returned object is owned by @fontchooser 6418 * and must not be modified or freed. 6419 */ 6420 extern(C) PangoFontFamily* function(GtkFontChooser* fontchooser) getFontFamily; 6421 /** 6422 * 6423 * Params: 6424 * fontchooser = a #GtkFontChooser 6425 * Returns: A #PangoFontFace representing the 6426 * selected font group details, or %NULL. The returned object is owned by 6427 * @fontchooser and must not be modified or freed. 6428 */ 6429 extern(C) PangoFontFace* function(GtkFontChooser* fontchooser) getFontFace; 6430 /** 6431 * 6432 * Params: 6433 * fontchooser = a #GtkFontChooser 6434 * Returns: A n integer representing the selected font size, 6435 * or -1 if no font size is selected. 6436 */ 6437 extern(C) int function(GtkFontChooser* fontchooser) getFontSize; 6438 /** */ 6439 extern(C) void function(GtkFontChooser* fontchooser, GtkFontFilterFunc filter, void* userData, GDestroyNotify destroy) setFilterFunc; 6440 /** */ 6441 extern(C) void function(GtkFontChooser* chooser, const(char)* fontname) fontActivated; 6442 /** */ 6443 extern(C) void function(GtkFontChooser* fontchooser, PangoFontMap* fontmap) setFontMap; 6444 /** 6445 * 6446 * Params: 6447 * fontchooser = a #GtkFontChooser 6448 * Returns: a #PangoFontMap, or %NULL 6449 */ 6450 extern(C) PangoFontMap* function(GtkFontChooser* fontchooser) getFontMap; 6451 void*[10] padding; 6452 } 6453 6454 struct GtkFontChooserWidget 6455 { 6456 GtkBox parentInstance; 6457 GtkFontChooserWidgetPrivate* priv; 6458 } 6459 6460 struct GtkFontChooserWidgetClass 6461 { 6462 /** 6463 * The parent class. 6464 */ 6465 GtkBoxClass parentClass; 6466 /** */ 6467 extern(C) void function() GtkReserved1; 6468 /** */ 6469 extern(C) void function() GtkReserved2; 6470 /** */ 6471 extern(C) void function() GtkReserved3; 6472 /** */ 6473 extern(C) void function() GtkReserved4; 6474 /** */ 6475 extern(C) void function() GtkReserved5; 6476 /** */ 6477 extern(C) void function() GtkReserved6; 6478 /** */ 6479 extern(C) void function() GtkReserved7; 6480 /** */ 6481 extern(C) void function() GtkReserved8; 6482 } 6483 6484 struct GtkFontChooserWidgetPrivate; 6485 6486 struct GtkFontSelection 6487 { 6488 GtkBox parentInstance; 6489 GtkFontSelectionPrivate* priv; 6490 } 6491 6492 struct GtkFontSelectionClass 6493 { 6494 GtkBoxClass parentClass; 6495 /** */ 6496 extern(C) void function() GtkReserved1; 6497 /** */ 6498 extern(C) void function() GtkReserved2; 6499 /** */ 6500 extern(C) void function() GtkReserved3; 6501 /** */ 6502 extern(C) void function() GtkReserved4; 6503 } 6504 6505 struct GtkFontSelectionDialog 6506 { 6507 GtkDialog parentInstance; 6508 GtkFontSelectionDialogPrivate* priv; 6509 } 6510 6511 struct GtkFontSelectionDialogClass 6512 { 6513 GtkDialogClass parentClass; 6514 /** */ 6515 extern(C) void function() GtkReserved1; 6516 /** */ 6517 extern(C) void function() GtkReserved2; 6518 /** */ 6519 extern(C) void function() GtkReserved3; 6520 /** */ 6521 extern(C) void function() GtkReserved4; 6522 } 6523 6524 struct GtkFontSelectionDialogPrivate; 6525 6526 struct GtkFontSelectionPrivate; 6527 6528 struct GtkFrame 6529 { 6530 GtkBin bin; 6531 GtkFramePrivate* priv; 6532 } 6533 6534 struct GtkFrameAccessible 6535 { 6536 GtkContainerAccessible parent; 6537 GtkFrameAccessiblePrivate* priv; 6538 } 6539 6540 struct GtkFrameAccessibleClass 6541 { 6542 GtkContainerAccessibleClass parentClass; 6543 } 6544 6545 struct GtkFrameAccessiblePrivate; 6546 6547 struct GtkFrameClass 6548 { 6549 /** 6550 * The parent class. 6551 */ 6552 GtkBinClass parentClass; 6553 /** */ 6554 extern(C) void function(GtkFrame* frame, GtkAllocation* allocation) computeChildAllocation; 6555 /** */ 6556 extern(C) void function() GtkReserved1; 6557 /** */ 6558 extern(C) void function() GtkReserved2; 6559 /** */ 6560 extern(C) void function() GtkReserved3; 6561 /** */ 6562 extern(C) void function() GtkReserved4; 6563 } 6564 6565 struct GtkFramePrivate; 6566 6567 struct GtkGLArea 6568 { 6569 GtkWidget parentInstance; 6570 } 6571 6572 /** 6573 * The `GtkGLAreaClass` structure contains only private data. 6574 * 6575 * Since: 3.16 6576 */ 6577 struct GtkGLAreaClass 6578 { 6579 GtkWidgetClass parentClass; 6580 /** */ 6581 extern(C) int function(GtkGLArea* area, GdkGLContext* context) render; 6582 /** */ 6583 extern(C) void function(GtkGLArea* area, int width, int height) resize; 6584 /** */ 6585 extern(C) GdkGLContext* function(GtkGLArea* area) createContext; 6586 void*[6] Padding; 6587 } 6588 6589 struct GtkGesture; 6590 6591 struct GtkGestureClass; 6592 6593 struct GtkGestureDrag; 6594 6595 struct GtkGestureDragClass; 6596 6597 struct GtkGestureLongPress; 6598 6599 struct GtkGestureLongPressClass; 6600 6601 struct GtkGestureMultiPress; 6602 6603 struct GtkGestureMultiPressClass; 6604 6605 struct GtkGesturePan; 6606 6607 struct GtkGesturePanClass; 6608 6609 struct GtkGestureRotate; 6610 6611 struct GtkGestureRotateClass; 6612 6613 struct GtkGestureSingle; 6614 6615 struct GtkGestureSingleClass; 6616 6617 struct GtkGestureSwipe; 6618 6619 struct GtkGestureSwipeClass; 6620 6621 struct GtkGestureZoom; 6622 6623 struct GtkGestureZoomClass; 6624 6625 struct GtkGradient; 6626 6627 struct GtkGrid 6628 { 6629 GtkContainer container; 6630 GtkGridPrivate* priv; 6631 } 6632 6633 struct GtkGridClass 6634 { 6635 /** 6636 * The parent class. 6637 */ 6638 GtkContainerClass parentClass; 6639 /** */ 6640 extern(C) void function() GtkReserved1; 6641 /** */ 6642 extern(C) void function() GtkReserved2; 6643 /** */ 6644 extern(C) void function() GtkReserved3; 6645 /** */ 6646 extern(C) void function() GtkReserved4; 6647 /** */ 6648 extern(C) void function() GtkReserved5; 6649 /** */ 6650 extern(C) void function() GtkReserved6; 6651 /** */ 6652 extern(C) void function() GtkReserved7; 6653 /** */ 6654 extern(C) void function() GtkReserved8; 6655 } 6656 6657 struct GtkGridPrivate; 6658 6659 struct GtkHBox 6660 { 6661 GtkBox box; 6662 } 6663 6664 struct GtkHBoxClass 6665 { 6666 GtkBoxClass parentClass; 6667 } 6668 6669 struct GtkHButtonBox 6670 { 6671 GtkButtonBox buttonBox; 6672 } 6673 6674 struct GtkHButtonBoxClass 6675 { 6676 GtkButtonBoxClass parentClass; 6677 } 6678 6679 struct GtkHPaned 6680 { 6681 GtkPaned paned; 6682 } 6683 6684 struct GtkHPanedClass 6685 { 6686 GtkPanedClass parentClass; 6687 } 6688 6689 struct GtkHSV 6690 { 6691 GtkWidget parentInstance; 6692 GtkHSVPrivate* priv; 6693 } 6694 6695 struct GtkHSVClass 6696 { 6697 GtkWidgetClass parentClass; 6698 /** */ 6699 extern(C) void function(GtkHSV* hsv) changed; 6700 /** */ 6701 extern(C) void function(GtkHSV* hsv, GtkDirectionType type) move; 6702 /** */ 6703 extern(C) void function() GtkReserved1; 6704 /** */ 6705 extern(C) void function() GtkReserved2; 6706 /** */ 6707 extern(C) void function() GtkReserved3; 6708 /** */ 6709 extern(C) void function() GtkReserved4; 6710 } 6711 6712 struct GtkHSVPrivate; 6713 6714 struct GtkHScale 6715 { 6716 GtkScale scale; 6717 } 6718 6719 struct GtkHScaleClass 6720 { 6721 GtkScaleClass parentClass; 6722 } 6723 6724 struct GtkHScrollbar 6725 { 6726 GtkScrollbar scrollbar; 6727 } 6728 6729 struct GtkHScrollbarClass 6730 { 6731 GtkScrollbarClass parentClass; 6732 } 6733 6734 struct GtkHSeparator 6735 { 6736 GtkSeparator separator; 6737 } 6738 6739 struct GtkHSeparatorClass 6740 { 6741 GtkSeparatorClass parentClass; 6742 } 6743 6744 struct GtkHandleBox 6745 { 6746 GtkBin bin; 6747 GtkHandleBoxPrivate* priv; 6748 } 6749 6750 struct GtkHandleBoxClass 6751 { 6752 /** 6753 * The parent class. 6754 */ 6755 GtkBinClass parentClass; 6756 /** */ 6757 extern(C) void function(GtkHandleBox* handleBox, GtkWidget* child) childAttached; 6758 /** */ 6759 extern(C) void function(GtkHandleBox* handleBox, GtkWidget* child) childDetached; 6760 /** */ 6761 extern(C) void function() GtkReserved1; 6762 /** */ 6763 extern(C) void function() GtkReserved2; 6764 /** */ 6765 extern(C) void function() GtkReserved3; 6766 /** */ 6767 extern(C) void function() GtkReserved4; 6768 } 6769 6770 struct GtkHandleBoxPrivate; 6771 6772 struct GtkHeaderBar 6773 { 6774 GtkContainer container; 6775 } 6776 6777 struct GtkHeaderBarClass 6778 { 6779 GtkContainerClass parentClass; 6780 /** */ 6781 extern(C) void function() GtkReserved1; 6782 /** */ 6783 extern(C) void function() GtkReserved2; 6784 /** */ 6785 extern(C) void function() GtkReserved3; 6786 /** */ 6787 extern(C) void function() GtkReserved4; 6788 } 6789 6790 struct GtkHeaderBarPrivate; 6791 6792 struct GtkIMContext 6793 { 6794 GObject parentInstance; 6795 } 6796 6797 struct GtkIMContextClass 6798 { 6799 GObjectClass parentClass; 6800 /** */ 6801 extern(C) void function(GtkIMContext* context) preeditStart; 6802 /** */ 6803 extern(C) void function(GtkIMContext* context) preeditEnd; 6804 /** */ 6805 extern(C) void function(GtkIMContext* context) preeditChanged; 6806 /** */ 6807 extern(C) void function(GtkIMContext* context, const(char)* str) commit; 6808 /** */ 6809 extern(C) int function(GtkIMContext* context) retrieveSurrounding; 6810 /** 6811 * 6812 * Params: 6813 * context = a #GtkIMContext 6814 * offset = offset from cursor position in chars; 6815 * a negative value means start before the cursor. 6816 * nChars = number of characters to delete. 6817 * Returns: %TRUE if the signal was handled. 6818 */ 6819 extern(C) int function(GtkIMContext* context, int offset, int nChars) deleteSurrounding; 6820 /** */ 6821 extern(C) void function(GtkIMContext* context, GdkWindow* window) setClientWindow; 6822 /** */ 6823 extern(C) void function(GtkIMContext* context, char** str, PangoAttrList** attrs, int* cursorPos) getPreeditString; 6824 /** 6825 * 6826 * Params: 6827 * context = a #GtkIMContext 6828 * event = the key event 6829 * Returns: %TRUE if the input method handled the key event. 6830 */ 6831 extern(C) int function(GtkIMContext* context, GdkEventKey* event) filterKeypress; 6832 /** */ 6833 extern(C) void function(GtkIMContext* context) focusIn; 6834 /** */ 6835 extern(C) void function(GtkIMContext* context) focusOut; 6836 /** */ 6837 extern(C) void function(GtkIMContext* context) reset; 6838 /** */ 6839 extern(C) void function(GtkIMContext* context, GdkRectangle* area) setCursorLocation; 6840 /** */ 6841 extern(C) void function(GtkIMContext* context, int usePreedit) setUsePreedit; 6842 /** */ 6843 extern(C) void function(GtkIMContext* context, const(char)* text, int len, int cursorIndex) setSurrounding; 6844 /** 6845 * 6846 * Params: 6847 * context = a #GtkIMContext 6848 * text = location to store a UTF-8 encoded 6849 * string of text holding context around the insertion point. 6850 * If the function returns %TRUE, then you must free the result 6851 * stored in this location with g_free(). 6852 * cursorIndex = location to store byte index of the insertion 6853 * cursor within @text. 6854 * Returns: %TRUE if surrounding text was provided; in this case 6855 * you must free the result stored in *text. 6856 */ 6857 extern(C) int function(GtkIMContext* context, char** text, int* cursorIndex) getSurrounding; 6858 /** */ 6859 extern(C) void function() GtkReserved1; 6860 /** */ 6861 extern(C) void function() GtkReserved2; 6862 /** */ 6863 extern(C) void function() GtkReserved3; 6864 /** */ 6865 extern(C) void function() GtkReserved4; 6866 /** */ 6867 extern(C) void function() GtkReserved5; 6868 /** */ 6869 extern(C) void function() GtkReserved6; 6870 } 6871 6872 /** 6873 * Bookkeeping information about a loadable input method. 6874 */ 6875 struct GtkIMContextInfo 6876 { 6877 /** 6878 * The unique identification string of the input method. 6879 */ 6880 const(char)* contextId; 6881 /** 6882 * The human-readable name of the input method. 6883 */ 6884 const(char)* contextName; 6885 /** 6886 * Translation domain to be used with dgettext() 6887 */ 6888 const(char)* domain; 6889 /** 6890 * Name of locale directory for use with bindtextdomain() 6891 */ 6892 const(char)* domainDirname; 6893 /** 6894 * A colon-separated list of locales where this input method 6895 * should be the default. The asterisk “*” sets the default for all locales. 6896 */ 6897 const(char)* defaultLocales; 6898 } 6899 6900 struct GtkIMContextSimple 6901 { 6902 GtkIMContext object; 6903 GtkIMContextSimplePrivate* priv; 6904 } 6905 6906 struct GtkIMContextSimpleClass 6907 { 6908 GtkIMContextClass parentClass; 6909 } 6910 6911 struct GtkIMContextSimplePrivate; 6912 6913 struct GtkIMMulticontext 6914 { 6915 GtkIMContext object; 6916 GtkIMMulticontextPrivate* priv; 6917 } 6918 6919 struct GtkIMMulticontextClass 6920 { 6921 GtkIMContextClass parentClass; 6922 /** */ 6923 extern(C) void function() GtkReserved1; 6924 /** */ 6925 extern(C) void function() GtkReserved2; 6926 /** */ 6927 extern(C) void function() GtkReserved3; 6928 /** */ 6929 extern(C) void function() GtkReserved4; 6930 } 6931 6932 struct GtkIMMulticontextPrivate; 6933 6934 struct GtkIconFactory 6935 { 6936 GObject parentInstance; 6937 GtkIconFactoryPrivate* priv; 6938 } 6939 6940 struct GtkIconFactoryClass 6941 { 6942 /** 6943 * The parent class. 6944 */ 6945 GObjectClass parentClass; 6946 /** */ 6947 extern(C) void function() GtkReserved1; 6948 /** */ 6949 extern(C) void function() GtkReserved2; 6950 /** */ 6951 extern(C) void function() GtkReserved3; 6952 /** */ 6953 extern(C) void function() GtkReserved4; 6954 } 6955 6956 struct GtkIconFactoryPrivate; 6957 6958 struct GtkIconInfo; 6959 6960 struct GtkIconInfoClass; 6961 6962 struct GtkIconSet; 6963 6964 struct GtkIconSource; 6965 6966 struct GtkIconTheme 6967 { 6968 GObject parentInstance; 6969 GtkIconThemePrivate* priv; 6970 } 6971 6972 struct GtkIconThemeClass 6973 { 6974 /** 6975 * The parent class. 6976 */ 6977 GObjectClass parentClass; 6978 /** */ 6979 extern(C) void function(GtkIconTheme* iconTheme) changed; 6980 /** */ 6981 extern(C) void function() GtkReserved1; 6982 /** */ 6983 extern(C) void function() GtkReserved2; 6984 /** */ 6985 extern(C) void function() GtkReserved3; 6986 /** */ 6987 extern(C) void function() GtkReserved4; 6988 } 6989 6990 struct GtkIconThemePrivate; 6991 6992 struct GtkIconView 6993 { 6994 GtkContainer parent; 6995 GtkIconViewPrivate* priv; 6996 } 6997 6998 struct GtkIconViewAccessible 6999 { 7000 GtkContainerAccessible parent; 7001 GtkIconViewAccessiblePrivate* priv; 7002 } 7003 7004 struct GtkIconViewAccessibleClass 7005 { 7006 GtkContainerAccessibleClass parentClass; 7007 } 7008 7009 struct GtkIconViewAccessiblePrivate; 7010 7011 struct GtkIconViewClass 7012 { 7013 GtkContainerClass parentClass; 7014 /** */ 7015 extern(C) void function(GtkIconView* iconView, GtkTreePath* path) itemActivated; 7016 /** */ 7017 extern(C) void function(GtkIconView* iconView) selectionChanged; 7018 /** */ 7019 extern(C) void function(GtkIconView* iconView) selectAll; 7020 /** */ 7021 extern(C) void function(GtkIconView* iconView) unselectAll; 7022 /** */ 7023 extern(C) void function(GtkIconView* iconView) selectCursorItem; 7024 /** */ 7025 extern(C) void function(GtkIconView* iconView) toggleCursorItem; 7026 /** */ 7027 extern(C) int function(GtkIconView* iconView, GtkMovementStep step, int count) moveCursor; 7028 /** */ 7029 extern(C) int function(GtkIconView* iconView) activateCursorItem; 7030 /** */ 7031 extern(C) void function() GtkReserved1; 7032 /** */ 7033 extern(C) void function() GtkReserved2; 7034 /** */ 7035 extern(C) void function() GtkReserved3; 7036 /** */ 7037 extern(C) void function() GtkReserved4; 7038 } 7039 7040 struct GtkIconViewPrivate; 7041 7042 struct GtkImage 7043 { 7044 GtkMisc misc; 7045 GtkImagePrivate* priv; 7046 } 7047 7048 struct GtkImageAccessible 7049 { 7050 GtkWidgetAccessible parent; 7051 GtkImageAccessiblePrivate* priv; 7052 } 7053 7054 struct GtkImageAccessibleClass 7055 { 7056 GtkWidgetAccessibleClass parentClass; 7057 } 7058 7059 struct GtkImageAccessiblePrivate; 7060 7061 struct GtkImageCellAccessible 7062 { 7063 GtkRendererCellAccessible parent; 7064 GtkImageCellAccessiblePrivate* priv; 7065 } 7066 7067 struct GtkImageCellAccessibleClass 7068 { 7069 GtkRendererCellAccessibleClass parentClass; 7070 } 7071 7072 struct GtkImageCellAccessiblePrivate; 7073 7074 struct GtkImageClass 7075 { 7076 GtkMiscClass parentClass; 7077 /** */ 7078 extern(C) void function() GtkReserved1; 7079 /** */ 7080 extern(C) void function() GtkReserved2; 7081 /** */ 7082 extern(C) void function() GtkReserved3; 7083 /** */ 7084 extern(C) void function() GtkReserved4; 7085 } 7086 7087 struct GtkImageMenuItem 7088 { 7089 GtkMenuItem menuItem; 7090 GtkImageMenuItemPrivate* priv; 7091 } 7092 7093 struct GtkImageMenuItemClass 7094 { 7095 /** 7096 * The parent class. 7097 */ 7098 GtkMenuItemClass parentClass; 7099 /** */ 7100 extern(C) void function() GtkReserved1; 7101 /** */ 7102 extern(C) void function() GtkReserved2; 7103 /** */ 7104 extern(C) void function() GtkReserved3; 7105 /** */ 7106 extern(C) void function() GtkReserved4; 7107 } 7108 7109 struct GtkImageMenuItemPrivate; 7110 7111 struct GtkImagePrivate; 7112 7113 struct GtkInfoBar 7114 { 7115 GtkBox parent; 7116 GtkInfoBarPrivate* priv; 7117 } 7118 7119 struct GtkInfoBarClass 7120 { 7121 GtkBoxClass parentClass; 7122 /** */ 7123 extern(C) void function(GtkInfoBar* infoBar, int responseId) response; 7124 /** */ 7125 extern(C) void function(GtkInfoBar* infoBar) close; 7126 /** */ 7127 extern(C) void function() GtkReserved1; 7128 /** */ 7129 extern(C) void function() GtkReserved2; 7130 /** */ 7131 extern(C) void function() GtkReserved3; 7132 /** */ 7133 extern(C) void function() GtkReserved4; 7134 } 7135 7136 struct GtkInfoBarPrivate; 7137 7138 struct GtkInvisible 7139 { 7140 GtkWidget widget; 7141 GtkInvisiblePrivate* priv; 7142 } 7143 7144 struct GtkInvisibleClass 7145 { 7146 GtkWidgetClass parentClass; 7147 /** */ 7148 extern(C) void function() GtkReserved1; 7149 /** */ 7150 extern(C) void function() GtkReserved2; 7151 /** */ 7152 extern(C) void function() GtkReserved3; 7153 /** */ 7154 extern(C) void function() GtkReserved4; 7155 } 7156 7157 struct GtkInvisiblePrivate; 7158 7159 struct GtkLabel 7160 { 7161 GtkMisc misc; 7162 GtkLabelPrivate* priv; 7163 } 7164 7165 struct GtkLabelAccessible 7166 { 7167 GtkWidgetAccessible parent; 7168 GtkLabelAccessiblePrivate* priv; 7169 } 7170 7171 struct GtkLabelAccessibleClass 7172 { 7173 GtkWidgetAccessibleClass parentClass; 7174 } 7175 7176 struct GtkLabelAccessiblePrivate; 7177 7178 struct GtkLabelClass 7179 { 7180 GtkMiscClass parentClass; 7181 /** */ 7182 extern(C) void function(GtkLabel* label, GtkMovementStep step, int count, int extendSelection) moveCursor; 7183 /** */ 7184 extern(C) void function(GtkLabel* label) copyClipboard; 7185 /** */ 7186 extern(C) void function(GtkLabel* label, GtkMenu* menu) populatePopup; 7187 /** */ 7188 extern(C) int function(GtkLabel* label, const(char)* uri) activateLink; 7189 /** */ 7190 extern(C) void function() GtkReserved1; 7191 /** */ 7192 extern(C) void function() GtkReserved2; 7193 /** */ 7194 extern(C) void function() GtkReserved3; 7195 /** */ 7196 extern(C) void function() GtkReserved4; 7197 /** */ 7198 extern(C) void function() GtkReserved5; 7199 /** */ 7200 extern(C) void function() GtkReserved6; 7201 /** */ 7202 extern(C) void function() GtkReserved7; 7203 /** */ 7204 extern(C) void function() GtkReserved8; 7205 } 7206 7207 struct GtkLabelPrivate; 7208 7209 struct GtkLabelSelectionInfo; 7210 7211 struct GtkLayout 7212 { 7213 GtkContainer container; 7214 GtkLayoutPrivate* priv; 7215 } 7216 7217 struct GtkLayoutClass 7218 { 7219 GtkContainerClass parentClass; 7220 /** */ 7221 extern(C) void function() GtkReserved1; 7222 /** */ 7223 extern(C) void function() GtkReserved2; 7224 /** */ 7225 extern(C) void function() GtkReserved3; 7226 /** */ 7227 extern(C) void function() GtkReserved4; 7228 } 7229 7230 struct GtkLayoutPrivate; 7231 7232 struct GtkLevelBar 7233 { 7234 GtkWidget parent; 7235 GtkLevelBarPrivate* priv; 7236 } 7237 7238 struct GtkLevelBarAccessible 7239 { 7240 GtkWidgetAccessible parent; 7241 GtkLevelBarAccessiblePrivate* priv; 7242 } 7243 7244 struct GtkLevelBarAccessibleClass 7245 { 7246 GtkWidgetAccessibleClass parentClass; 7247 } 7248 7249 struct GtkLevelBarAccessiblePrivate; 7250 7251 struct GtkLevelBarClass 7252 { 7253 GtkWidgetClass parentClass; 7254 /** */ 7255 extern(C) void function(GtkLevelBar* self, const(char)* name) offsetChanged; 7256 void*[16] padding; 7257 } 7258 7259 struct GtkLevelBarPrivate; 7260 7261 struct GtkLinkButton 7262 { 7263 GtkButton parentInstance; 7264 GtkLinkButtonPrivate* priv; 7265 } 7266 7267 struct GtkLinkButtonAccessible 7268 { 7269 GtkButtonAccessible parent; 7270 GtkLinkButtonAccessiblePrivate* priv; 7271 } 7272 7273 struct GtkLinkButtonAccessibleClass 7274 { 7275 GtkButtonAccessibleClass parentClass; 7276 } 7277 7278 struct GtkLinkButtonAccessiblePrivate; 7279 7280 /** 7281 * The #GtkLinkButtonClass contains only 7282 * private data. 7283 */ 7284 struct GtkLinkButtonClass 7285 { 7286 GtkButtonClass parentClass; 7287 /** */ 7288 extern(C) int function(GtkLinkButton* button) activateLink; 7289 /** */ 7290 extern(C) void function() GtkPadding1; 7291 /** */ 7292 extern(C) void function() GtkPadding2; 7293 /** */ 7294 extern(C) void function() GtkPadding3; 7295 /** */ 7296 extern(C) void function() GtkPadding4; 7297 } 7298 7299 struct GtkLinkButtonPrivate; 7300 7301 struct GtkListBox 7302 { 7303 GtkContainer parentInstance; 7304 } 7305 7306 struct GtkListBoxAccessible 7307 { 7308 GtkContainerAccessible parent; 7309 GtkListBoxAccessiblePrivate* priv; 7310 } 7311 7312 struct GtkListBoxAccessibleClass 7313 { 7314 GtkContainerAccessibleClass parentClass; 7315 } 7316 7317 struct GtkListBoxAccessiblePrivate; 7318 7319 struct GtkListBoxClass 7320 { 7321 /** 7322 * The parent class. 7323 */ 7324 GtkContainerClass parentClass; 7325 /** */ 7326 extern(C) void function(GtkListBox* box, GtkListBoxRow* row) rowSelected; 7327 /** */ 7328 extern(C) void function(GtkListBox* box, GtkListBoxRow* row) rowActivated; 7329 /** */ 7330 extern(C) void function(GtkListBox* box) activateCursorRow; 7331 /** */ 7332 extern(C) void function(GtkListBox* box) toggleCursorRow; 7333 /** */ 7334 extern(C) void function(GtkListBox* box, GtkMovementStep step, int count) moveCursor; 7335 /** */ 7336 extern(C) void function(GtkListBox* box) selectedRowsChanged; 7337 /** */ 7338 extern(C) void function(GtkListBox* box) selectAll; 7339 /** */ 7340 extern(C) void function(GtkListBox* box) unselectAll; 7341 /** */ 7342 extern(C) void function() GtkReserved1; 7343 /** */ 7344 extern(C) void function() GtkReserved2; 7345 /** */ 7346 extern(C) void function() GtkReserved3; 7347 } 7348 7349 struct GtkListBoxRow 7350 { 7351 GtkBin parentInstance; 7352 } 7353 7354 struct GtkListBoxRowAccessible 7355 { 7356 GtkContainerAccessible parent; 7357 } 7358 7359 struct GtkListBoxRowAccessibleClass 7360 { 7361 GtkContainerAccessibleClass parentClass; 7362 } 7363 7364 struct GtkListBoxRowClass 7365 { 7366 /** 7367 * The parent class. 7368 */ 7369 GtkBinClass parentClass; 7370 /** */ 7371 extern(C) void function(GtkListBoxRow* row) activate; 7372 /** */ 7373 extern(C) void function() GtkReserved1; 7374 /** */ 7375 extern(C) void function() GtkReserved2; 7376 } 7377 7378 struct GtkListStore 7379 { 7380 GObject parent; 7381 GtkListStorePrivate* priv; 7382 } 7383 7384 struct GtkListStoreClass 7385 { 7386 GObjectClass parentClass; 7387 /** */ 7388 extern(C) void function() GtkReserved1; 7389 /** */ 7390 extern(C) void function() GtkReserved2; 7391 /** */ 7392 extern(C) void function() GtkReserved3; 7393 /** */ 7394 extern(C) void function() GtkReserved4; 7395 } 7396 7397 struct GtkListStorePrivate; 7398 7399 struct GtkLockButton 7400 { 7401 GtkButton parent; 7402 GtkLockButtonPrivate* priv; 7403 } 7404 7405 struct GtkLockButtonAccessible 7406 { 7407 GtkButtonAccessible parent; 7408 GtkLockButtonAccessiblePrivate* priv; 7409 } 7410 7411 struct GtkLockButtonAccessibleClass 7412 { 7413 GtkButtonAccessibleClass parentClass; 7414 } 7415 7416 struct GtkLockButtonAccessiblePrivate; 7417 7418 struct GtkLockButtonClass 7419 { 7420 /** 7421 * The parent class. 7422 */ 7423 GtkButtonClass parentClass; 7424 /** */ 7425 extern(C) void function() reserved0; 7426 /** */ 7427 extern(C) void function() reserved1; 7428 /** */ 7429 extern(C) void function() reserved2; 7430 /** */ 7431 extern(C) void function() reserved3; 7432 /** */ 7433 extern(C) void function() reserved4; 7434 /** */ 7435 extern(C) void function() reserved5; 7436 /** */ 7437 extern(C) void function() reserved6; 7438 /** */ 7439 extern(C) void function() reserved7; 7440 } 7441 7442 struct GtkLockButtonPrivate; 7443 7444 struct GtkMenu 7445 { 7446 GtkMenuShell menuShell; 7447 GtkMenuPrivate* priv; 7448 } 7449 7450 struct GtkMenuAccessible 7451 { 7452 GtkMenuShellAccessible parent; 7453 GtkMenuAccessiblePrivate* priv; 7454 } 7455 7456 struct GtkMenuAccessibleClass 7457 { 7458 GtkMenuShellAccessibleClass parentClass; 7459 } 7460 7461 struct GtkMenuAccessiblePrivate; 7462 7463 struct GtkMenuBar 7464 { 7465 GtkMenuShell menuShell; 7466 GtkMenuBarPrivate* priv; 7467 } 7468 7469 struct GtkMenuBarClass 7470 { 7471 GtkMenuShellClass parentClass; 7472 /** */ 7473 extern(C) void function() GtkReserved1; 7474 /** */ 7475 extern(C) void function() GtkReserved2; 7476 /** */ 7477 extern(C) void function() GtkReserved3; 7478 /** */ 7479 extern(C) void function() GtkReserved4; 7480 } 7481 7482 struct GtkMenuBarPrivate; 7483 7484 struct GtkMenuButton 7485 { 7486 GtkToggleButton parent; 7487 GtkMenuButtonPrivate* priv; 7488 } 7489 7490 struct GtkMenuButtonAccessible 7491 { 7492 GtkToggleButtonAccessible parent; 7493 GtkMenuButtonAccessiblePrivate* priv; 7494 } 7495 7496 struct GtkMenuButtonAccessibleClass 7497 { 7498 GtkToggleButtonAccessibleClass parentClass; 7499 } 7500 7501 struct GtkMenuButtonAccessiblePrivate; 7502 7503 struct GtkMenuButtonClass 7504 { 7505 GtkToggleButtonClass parentClass; 7506 /** */ 7507 extern(C) void function() GtkReserved1; 7508 /** */ 7509 extern(C) void function() GtkReserved2; 7510 /** */ 7511 extern(C) void function() GtkReserved3; 7512 /** */ 7513 extern(C) void function() GtkReserved4; 7514 } 7515 7516 struct GtkMenuButtonPrivate; 7517 7518 struct GtkMenuClass 7519 { 7520 GtkMenuShellClass parentClass; 7521 /** */ 7522 extern(C) void function() GtkReserved1; 7523 /** */ 7524 extern(C) void function() GtkReserved2; 7525 /** */ 7526 extern(C) void function() GtkReserved3; 7527 /** */ 7528 extern(C) void function() GtkReserved4; 7529 } 7530 7531 struct GtkMenuItem 7532 { 7533 GtkBin bin; 7534 GtkMenuItemPrivate* priv; 7535 } 7536 7537 struct GtkMenuItemAccessible 7538 { 7539 GtkContainerAccessible parent; 7540 GtkMenuItemAccessiblePrivate* priv; 7541 } 7542 7543 struct GtkMenuItemAccessibleClass 7544 { 7545 GtkContainerAccessibleClass parentClass; 7546 } 7547 7548 struct GtkMenuItemAccessiblePrivate; 7549 7550 struct GtkMenuItemClass 7551 { 7552 /** 7553 * The parent class. 7554 */ 7555 GtkBinClass parentClass; 7556 import std.bitmanip: bitfields; 7557 mixin(bitfields!( 7558 uint, "hideOnActivate", 1, 7559 uint, "", 31 7560 )); 7561 /** */ 7562 extern(C) void function(GtkMenuItem* menuItem) activate; 7563 /** */ 7564 extern(C) void function(GtkMenuItem* menuItem) activateItem; 7565 /** */ 7566 extern(C) void function(GtkMenuItem* menuItem, int* requisition) toggleSizeRequest; 7567 /** */ 7568 extern(C) void function(GtkMenuItem* menuItem, int allocation) toggleSizeAllocate; 7569 /** */ 7570 extern(C) void function(GtkMenuItem* menuItem, const(char)* label) setLabel; 7571 /** 7572 * 7573 * Params: 7574 * menuItem = a #GtkMenuItem 7575 * Returns: The text in the @menu_item label. This is the internal 7576 * string used by the label, and must not be modified. 7577 */ 7578 extern(C) const(char)* function(GtkMenuItem* menuItem) getLabel; 7579 /** */ 7580 extern(C) void function(GtkMenuItem* menuItem) select; 7581 /** */ 7582 extern(C) void function(GtkMenuItem* menuItem) deselect; 7583 /** */ 7584 extern(C) void function() GtkReserved1; 7585 /** */ 7586 extern(C) void function() GtkReserved2; 7587 /** */ 7588 extern(C) void function() GtkReserved3; 7589 /** */ 7590 extern(C) void function() GtkReserved4; 7591 } 7592 7593 struct GtkMenuItemPrivate; 7594 7595 struct GtkMenuPrivate; 7596 7597 struct GtkMenuShell 7598 { 7599 GtkContainer container; 7600 GtkMenuShellPrivate* priv; 7601 } 7602 7603 struct GtkMenuShellAccessible 7604 { 7605 GtkContainerAccessible parent; 7606 GtkMenuShellAccessiblePrivate* priv; 7607 } 7608 7609 struct GtkMenuShellAccessibleClass 7610 { 7611 GtkContainerAccessibleClass parentClass; 7612 } 7613 7614 struct GtkMenuShellAccessiblePrivate; 7615 7616 struct GtkMenuShellClass 7617 { 7618 GtkContainerClass parentClass; 7619 import std.bitmanip: bitfields; 7620 mixin(bitfields!( 7621 uint, "submenuPlacement", 1, 7622 uint, "", 31 7623 )); 7624 /** */ 7625 extern(C) void function(GtkMenuShell* menuShell) deactivate; 7626 /** */ 7627 extern(C) void function(GtkMenuShell* menuShell) selectionDone; 7628 /** */ 7629 extern(C) void function(GtkMenuShell* menuShell, GtkMenuDirectionType direction) moveCurrent; 7630 /** */ 7631 extern(C) void function(GtkMenuShell* menuShell, int forceHide) activateCurrent; 7632 /** */ 7633 extern(C) void function(GtkMenuShell* menuShell) cancel; 7634 /** */ 7635 extern(C) void function(GtkMenuShell* menuShell, GtkWidget* menuItem) selectItem; 7636 /** */ 7637 extern(C) void function(GtkMenuShell* menuShell, GtkWidget* child, int position) insert; 7638 /** */ 7639 extern(C) int function(GtkMenuShell* menuShell) getPopupDelay; 7640 /** */ 7641 extern(C) int function(GtkMenuShell* menuShell, int distance) moveSelected; 7642 /** */ 7643 extern(C) void function() GtkReserved1; 7644 /** */ 7645 extern(C) void function() GtkReserved2; 7646 /** */ 7647 extern(C) void function() GtkReserved3; 7648 /** */ 7649 extern(C) void function() GtkReserved4; 7650 } 7651 7652 struct GtkMenuShellPrivate; 7653 7654 struct GtkMenuToolButton 7655 { 7656 GtkToolButton parent; 7657 GtkMenuToolButtonPrivate* priv; 7658 } 7659 7660 struct GtkMenuToolButtonClass 7661 { 7662 /** 7663 * The parent class. 7664 */ 7665 GtkToolButtonClass parentClass; 7666 /** */ 7667 extern(C) void function(GtkMenuToolButton* button) showMenu; 7668 /** */ 7669 extern(C) void function() GtkReserved1; 7670 /** */ 7671 extern(C) void function() GtkReserved2; 7672 /** */ 7673 extern(C) void function() GtkReserved3; 7674 /** */ 7675 extern(C) void function() GtkReserved4; 7676 } 7677 7678 struct GtkMenuToolButtonPrivate; 7679 7680 struct GtkMessageDialog 7681 { 7682 GtkDialog parentInstance; 7683 GtkMessageDialogPrivate* priv; 7684 } 7685 7686 struct GtkMessageDialogClass 7687 { 7688 GtkDialogClass parentClass; 7689 /** */ 7690 extern(C) void function() GtkReserved1; 7691 /** */ 7692 extern(C) void function() GtkReserved2; 7693 /** */ 7694 extern(C) void function() GtkReserved3; 7695 /** */ 7696 extern(C) void function() GtkReserved4; 7697 } 7698 7699 struct GtkMessageDialogPrivate; 7700 7701 struct GtkMisc 7702 { 7703 GtkWidget widget; 7704 GtkMiscPrivate* priv; 7705 } 7706 7707 struct GtkMiscClass 7708 { 7709 GtkWidgetClass parentClass; 7710 /** */ 7711 extern(C) void function() GtkReserved1; 7712 /** */ 7713 extern(C) void function() GtkReserved2; 7714 /** */ 7715 extern(C) void function() GtkReserved3; 7716 /** */ 7717 extern(C) void function() GtkReserved4; 7718 } 7719 7720 struct GtkMiscPrivate; 7721 7722 struct GtkModelButton; 7723 7724 struct GtkMountOperation 7725 { 7726 GMountOperation parentInstance; 7727 GtkMountOperationPrivate* priv; 7728 } 7729 7730 struct GtkMountOperationClass 7731 { 7732 /** 7733 * The parent class. 7734 */ 7735 GMountOperationClass parentClass; 7736 /** */ 7737 extern(C) void function() GtkReserved1; 7738 /** */ 7739 extern(C) void function() GtkReserved2; 7740 /** */ 7741 extern(C) void function() GtkReserved3; 7742 /** */ 7743 extern(C) void function() GtkReserved4; 7744 } 7745 7746 struct GtkMountOperationPrivate; 7747 7748 struct GtkNativeDialog 7749 { 7750 GObject parentInstance; 7751 } 7752 7753 struct GtkNativeDialogClass 7754 { 7755 GObjectClass parentClass; 7756 /** */ 7757 extern(C) void function(GtkNativeDialog* self, int responseId) response; 7758 /** */ 7759 extern(C) void function(GtkNativeDialog* self) show; 7760 /** */ 7761 extern(C) void function(GtkNativeDialog* self) hide; 7762 /** */ 7763 extern(C) void function() GtkReserved1; 7764 /** */ 7765 extern(C) void function() GtkReserved2; 7766 /** */ 7767 extern(C) void function() GtkReserved3; 7768 /** */ 7769 extern(C) void function() GtkReserved4; 7770 } 7771 7772 struct GtkNotebook 7773 { 7774 GtkContainer container; 7775 GtkNotebookPrivate* priv; 7776 } 7777 7778 struct GtkNotebookAccessible 7779 { 7780 GtkContainerAccessible parent; 7781 GtkNotebookAccessiblePrivate* priv; 7782 } 7783 7784 struct GtkNotebookAccessibleClass 7785 { 7786 GtkContainerAccessibleClass parentClass; 7787 } 7788 7789 struct GtkNotebookAccessiblePrivate; 7790 7791 struct GtkNotebookClass 7792 { 7793 GtkContainerClass parentClass; 7794 /** */ 7795 extern(C) void function(GtkNotebook* notebook, GtkWidget* page, uint pageNum) switchPage; 7796 /** */ 7797 extern(C) int function(GtkNotebook* notebook, int moveFocus) selectPage; 7798 /** */ 7799 extern(C) int function(GtkNotebook* notebook, GtkNotebookTab type) focusTab; 7800 /** */ 7801 extern(C) int function(GtkNotebook* notebook, int offset) changeCurrentPage; 7802 /** */ 7803 extern(C) void function(GtkNotebook* notebook, GtkDirectionType direction) moveFocusOut; 7804 /** */ 7805 extern(C) int function(GtkNotebook* notebook, GtkDirectionType direction, int moveToLast) reorderTab; 7806 /** */ 7807 extern(C) int function(GtkNotebook* notebook, GtkWidget* child, GtkWidget* tabLabel, GtkWidget* menuLabel, int position) insertPage; 7808 /** */ 7809 extern(C) GtkNotebook* function(GtkNotebook* notebook, GtkWidget* page, int x, int y) createWindow; 7810 /** */ 7811 extern(C) void function(GtkNotebook* notebook, GtkWidget* child, uint pageNum) pageReordered; 7812 /** */ 7813 extern(C) void function(GtkNotebook* notebook, GtkWidget* child, uint pageNum) pageRemoved; 7814 /** */ 7815 extern(C) void function(GtkNotebook* notebook, GtkWidget* child, uint pageNum) pageAdded; 7816 /** */ 7817 extern(C) void function() GtkReserved1; 7818 /** */ 7819 extern(C) void function() GtkReserved2; 7820 /** */ 7821 extern(C) void function() GtkReserved3; 7822 /** */ 7823 extern(C) void function() GtkReserved4; 7824 /** */ 7825 extern(C) void function() GtkReserved5; 7826 /** */ 7827 extern(C) void function() GtkReserved6; 7828 /** */ 7829 extern(C) void function() GtkReserved7; 7830 /** */ 7831 extern(C) void function() GtkReserved8; 7832 } 7833 7834 struct GtkNotebookPageAccessible 7835 { 7836 AtkObject parent; 7837 GtkNotebookPageAccessiblePrivate* priv; 7838 } 7839 7840 struct GtkNotebookPageAccessibleClass 7841 { 7842 AtkObjectClass parentClass; 7843 } 7844 7845 struct GtkNotebookPageAccessiblePrivate; 7846 7847 struct GtkNotebookPrivate; 7848 7849 struct GtkNumerableIcon 7850 { 7851 GEmblemedIcon parent; 7852 GtkNumerableIconPrivate* priv; 7853 } 7854 7855 struct GtkNumerableIconClass 7856 { 7857 GEmblemedIconClass parentClass; 7858 void*[16] padding; 7859 } 7860 7861 struct GtkNumerableIconPrivate; 7862 7863 struct GtkOffscreenWindow 7864 { 7865 GtkWindow parentObject; 7866 } 7867 7868 struct GtkOffscreenWindowClass 7869 { 7870 /** 7871 * The parent class. 7872 */ 7873 GtkWindowClass parentClass; 7874 /** */ 7875 extern(C) void function() GtkReserved1; 7876 /** */ 7877 extern(C) void function() GtkReserved2; 7878 /** */ 7879 extern(C) void function() GtkReserved3; 7880 /** */ 7881 extern(C) void function() GtkReserved4; 7882 } 7883 7884 struct GtkOrientable; 7885 7886 struct GtkOrientableIface 7887 { 7888 GTypeInterface baseIface; 7889 } 7890 7891 struct GtkOverlay 7892 { 7893 GtkBin parent; 7894 GtkOverlayPrivate* priv; 7895 } 7896 7897 struct GtkOverlayClass 7898 { 7899 /** 7900 * The parent class. 7901 */ 7902 GtkBinClass parentClass; 7903 /** */ 7904 extern(C) int function(GtkOverlay* overlay, GtkWidget* widget, GtkAllocation* allocation) getChildPosition; 7905 /** */ 7906 extern(C) void function() GtkReserved1; 7907 /** */ 7908 extern(C) void function() GtkReserved2; 7909 /** */ 7910 extern(C) void function() GtkReserved3; 7911 /** */ 7912 extern(C) void function() GtkReserved4; 7913 /** */ 7914 extern(C) void function() GtkReserved5; 7915 /** */ 7916 extern(C) void function() GtkReserved6; 7917 /** */ 7918 extern(C) void function() GtkReserved7; 7919 /** */ 7920 extern(C) void function() GtkReserved8; 7921 } 7922 7923 struct GtkOverlayPrivate; 7924 7925 /** 7926 * Struct defining a pad action entry. 7927 */ 7928 struct GtkPadActionEntry 7929 { 7930 /** 7931 * the type of pad feature that will trigger this action entry. 7932 */ 7933 GtkPadActionType type; 7934 /** 7935 * the 0-indexed button/ring/strip number that will trigger this action 7936 * entry. 7937 */ 7938 int index; 7939 /** 7940 * the mode that will trigger this action entry, or -1 for all modes. 7941 */ 7942 int mode; 7943 /** 7944 * Human readable description of this action entry, this string should 7945 * be deemed user-visible. 7946 */ 7947 char* label; 7948 /** 7949 * action name that will be activated in the #GActionGroup. 7950 */ 7951 char* actionName; 7952 } 7953 7954 struct GtkPadController; 7955 7956 struct GtkPadControllerClass; 7957 7958 /** 7959 * See also gtk_print_settings_set_page_ranges(). 7960 */ 7961 struct GtkPageRange 7962 { 7963 /** 7964 * start of page range. 7965 */ 7966 int start; 7967 /** 7968 * end of page range. 7969 */ 7970 int end; 7971 } 7972 7973 struct GtkPageSetup; 7974 7975 struct GtkPaned 7976 { 7977 GtkContainer container; 7978 GtkPanedPrivate* priv; 7979 } 7980 7981 struct GtkPanedAccessible 7982 { 7983 GtkContainerAccessible parent; 7984 GtkPanedAccessiblePrivate* priv; 7985 } 7986 7987 struct GtkPanedAccessibleClass 7988 { 7989 GtkContainerAccessibleClass parentClass; 7990 } 7991 7992 struct GtkPanedAccessiblePrivate; 7993 7994 struct GtkPanedClass 7995 { 7996 GtkContainerClass parentClass; 7997 /** */ 7998 extern(C) int function(GtkPaned* paned, int reverse) cycleChildFocus; 7999 /** */ 8000 extern(C) int function(GtkPaned* paned) toggleHandleFocus; 8001 /** */ 8002 extern(C) int function(GtkPaned* paned, GtkScrollType scroll) moveHandle; 8003 /** */ 8004 extern(C) int function(GtkPaned* paned, int reverse) cycleHandleFocus; 8005 /** */ 8006 extern(C) int function(GtkPaned* paned) acceptPosition; 8007 /** */ 8008 extern(C) int function(GtkPaned* paned) cancelPosition; 8009 /** */ 8010 extern(C) void function() GtkReserved1; 8011 /** */ 8012 extern(C) void function() GtkReserved2; 8013 /** */ 8014 extern(C) void function() GtkReserved3; 8015 /** */ 8016 extern(C) void function() GtkReserved4; 8017 } 8018 8019 struct GtkPanedPrivate; 8020 8021 struct GtkPaperSize; 8022 8023 struct GtkPlacesSidebar; 8024 8025 struct GtkPlacesSidebarClass; 8026 8027 struct GtkPlug 8028 { 8029 GtkWindow window; 8030 GtkPlugPrivate* priv; 8031 } 8032 8033 struct GtkPlugClass 8034 { 8035 GtkWindowClass parentClass; 8036 /** */ 8037 extern(C) void function(GtkPlug* plug) embedded; 8038 /** */ 8039 extern(C) void function() GtkReserved1; 8040 /** */ 8041 extern(C) void function() GtkReserved2; 8042 /** */ 8043 extern(C) void function() GtkReserved3; 8044 /** */ 8045 extern(C) void function() GtkReserved4; 8046 } 8047 8048 struct GtkPlugPrivate; 8049 8050 struct GtkPopover 8051 { 8052 GtkBin parentInstance; 8053 GtkPopoverPrivate* priv; 8054 } 8055 8056 struct GtkPopoverAccessible 8057 { 8058 GtkContainerAccessible parent; 8059 } 8060 8061 struct GtkPopoverAccessibleClass 8062 { 8063 GtkContainerAccessibleClass parentClass; 8064 } 8065 8066 struct GtkPopoverClass 8067 { 8068 GtkBinClass parentClass; 8069 /** */ 8070 extern(C) void function(GtkPopover* popover) closed; 8071 void*[10] reserved; 8072 } 8073 8074 struct GtkPopoverMenu; 8075 8076 struct GtkPopoverMenuClass 8077 { 8078 GtkPopoverClass parentClass; 8079 void*[10] reserved; 8080 } 8081 8082 struct GtkPopoverPrivate; 8083 8084 struct GtkPrintContext; 8085 8086 struct GtkPrintOperation 8087 { 8088 GObject parentInstance; 8089 GtkPrintOperationPrivate* priv; 8090 } 8091 8092 struct GtkPrintOperationClass 8093 { 8094 /** 8095 * The parent class. 8096 */ 8097 GObjectClass parentClass; 8098 /** */ 8099 extern(C) void function(GtkPrintOperation* operation, GtkPrintOperationResult result) done; 8100 /** */ 8101 extern(C) void function(GtkPrintOperation* operation, GtkPrintContext* context) beginPrint; 8102 /** */ 8103 extern(C) int function(GtkPrintOperation* operation, GtkPrintContext* context) paginate; 8104 /** */ 8105 extern(C) void function(GtkPrintOperation* operation, GtkPrintContext* context, int pageNr, GtkPageSetup* setup) requestPageSetup; 8106 /** */ 8107 extern(C) void function(GtkPrintOperation* operation, GtkPrintContext* context, int pageNr) drawPage; 8108 /** */ 8109 extern(C) void function(GtkPrintOperation* operation, GtkPrintContext* context) endPrint; 8110 /** */ 8111 extern(C) void function(GtkPrintOperation* operation) statusChanged; 8112 /** */ 8113 extern(C) GtkWidget* function(GtkPrintOperation* operation) createCustomWidget; 8114 /** */ 8115 extern(C) void function(GtkPrintOperation* operation, GtkWidget* widget) customWidgetApply; 8116 /** */ 8117 extern(C) int function(GtkPrintOperation* operation, GtkPrintOperationPreview* preview, GtkPrintContext* context, GtkWindow* parent) preview; 8118 /** */ 8119 extern(C) void function(GtkPrintOperation* operation, GtkWidget* widget, GtkPageSetup* setup, GtkPrintSettings* settings) updateCustomWidget; 8120 /** */ 8121 extern(C) void function() GtkReserved1; 8122 /** */ 8123 extern(C) void function() GtkReserved2; 8124 /** */ 8125 extern(C) void function() GtkReserved3; 8126 /** */ 8127 extern(C) void function() GtkReserved4; 8128 /** */ 8129 extern(C) void function() GtkReserved5; 8130 /** */ 8131 extern(C) void function() GtkReserved6; 8132 /** */ 8133 extern(C) void function() GtkReserved7; 8134 /** */ 8135 extern(C) void function() GtkReserved8; 8136 } 8137 8138 struct GtkPrintOperationPreview; 8139 8140 struct GtkPrintOperationPreviewIface 8141 { 8142 GTypeInterface gIface; 8143 /** */ 8144 extern(C) void function(GtkPrintOperationPreview* preview, GtkPrintContext* context) ready; 8145 /** */ 8146 extern(C) void function(GtkPrintOperationPreview* preview, GtkPrintContext* context, GtkPageSetup* pageSetup) gotPageSize; 8147 /** */ 8148 extern(C) void function(GtkPrintOperationPreview* preview, int pageNr) renderPage; 8149 /** 8150 * 8151 * Params: 8152 * preview = a #GtkPrintOperationPreview 8153 * pageNr = a page number 8154 * Returns: %TRUE if the page has been selected for printing 8155 */ 8156 extern(C) int function(GtkPrintOperationPreview* preview, int pageNr) isSelected; 8157 /** */ 8158 extern(C) void function(GtkPrintOperationPreview* preview) endPreview; 8159 /** */ 8160 extern(C) void function() GtkReserved1; 8161 /** */ 8162 extern(C) void function() GtkReserved2; 8163 /** */ 8164 extern(C) void function() GtkReserved3; 8165 /** */ 8166 extern(C) void function() GtkReserved4; 8167 /** */ 8168 extern(C) void function() GtkReserved5; 8169 /** */ 8170 extern(C) void function() GtkReserved6; 8171 /** */ 8172 extern(C) void function() GtkReserved7; 8173 /** */ 8174 extern(C) void function() GtkReserved8; 8175 } 8176 8177 struct GtkPrintOperationPrivate; 8178 8179 struct GtkPrintSettings; 8180 8181 struct GtkProgressBar 8182 { 8183 GtkWidget parent; 8184 GtkProgressBarPrivate* priv; 8185 } 8186 8187 struct GtkProgressBarAccessible 8188 { 8189 GtkWidgetAccessible parent; 8190 GtkProgressBarAccessiblePrivate* priv; 8191 } 8192 8193 struct GtkProgressBarAccessibleClass 8194 { 8195 GtkWidgetAccessibleClass parentClass; 8196 } 8197 8198 struct GtkProgressBarAccessiblePrivate; 8199 8200 struct GtkProgressBarClass 8201 { 8202 GtkWidgetClass parentClass; 8203 /** */ 8204 extern(C) void function() GtkReserved1; 8205 /** */ 8206 extern(C) void function() GtkReserved2; 8207 /** */ 8208 extern(C) void function() GtkReserved3; 8209 /** */ 8210 extern(C) void function() GtkReserved4; 8211 } 8212 8213 struct GtkProgressBarPrivate; 8214 8215 struct GtkRadioAction 8216 { 8217 GtkToggleAction parent; 8218 GtkRadioActionPrivate* privateData; 8219 } 8220 8221 struct GtkRadioActionClass 8222 { 8223 GtkToggleActionClass parentClass; 8224 /** */ 8225 extern(C) void function(GtkRadioAction* action, GtkRadioAction* current) changed; 8226 /** */ 8227 extern(C) void function() GtkReserved1; 8228 /** */ 8229 extern(C) void function() GtkReserved2; 8230 /** */ 8231 extern(C) void function() GtkReserved3; 8232 /** */ 8233 extern(C) void function() GtkReserved4; 8234 } 8235 8236 /** 8237 * #GtkRadioActionEntry structs are used with 8238 * gtk_action_group_add_radio_actions() to construct groups of radio actions. 8239 */ 8240 struct GtkRadioActionEntry 8241 { 8242 /** 8243 * The name of the action. 8244 */ 8245 const(char)* name; 8246 /** 8247 * The stock id for the action, or the name of an icon from the 8248 * icon theme. 8249 */ 8250 const(char)* stockId; 8251 /** 8252 * The label for the action. This field should typically be marked 8253 * for translation, see gtk_action_group_set_translation_domain(). 8254 */ 8255 const(char)* label; 8256 /** 8257 * The accelerator for the action, in the format understood by 8258 * gtk_accelerator_parse(). 8259 */ 8260 const(char)* accelerator; 8261 /** 8262 * The tooltip for the action. This field should typically be 8263 * marked for translation, see gtk_action_group_set_translation_domain(). 8264 */ 8265 const(char)* tooltip; 8266 /** 8267 * The value to set on the radio action. See 8268 * gtk_radio_action_get_current_value(). 8269 */ 8270 int value; 8271 } 8272 8273 struct GtkRadioActionPrivate; 8274 8275 struct GtkRadioButton 8276 { 8277 GtkCheckButton checkButton; 8278 GtkRadioButtonPrivate* priv; 8279 } 8280 8281 struct GtkRadioButtonAccessible 8282 { 8283 GtkToggleButtonAccessible parent; 8284 GtkRadioButtonAccessiblePrivate* priv; 8285 } 8286 8287 struct GtkRadioButtonAccessibleClass 8288 { 8289 GtkToggleButtonAccessibleClass parentClass; 8290 } 8291 8292 struct GtkRadioButtonAccessiblePrivate; 8293 8294 struct GtkRadioButtonClass 8295 { 8296 GtkCheckButtonClass parentClass; 8297 /** */ 8298 extern(C) void function(GtkRadioButton* radioButton) groupChanged; 8299 /** */ 8300 extern(C) void function() GtkReserved1; 8301 /** */ 8302 extern(C) void function() GtkReserved2; 8303 /** */ 8304 extern(C) void function() GtkReserved3; 8305 /** */ 8306 extern(C) void function() GtkReserved4; 8307 } 8308 8309 struct GtkRadioButtonPrivate; 8310 8311 struct GtkRadioMenuItem 8312 { 8313 GtkCheckMenuItem checkMenuItem; 8314 GtkRadioMenuItemPrivate* priv; 8315 } 8316 8317 struct GtkRadioMenuItemAccessible 8318 { 8319 GtkCheckMenuItemAccessible parent; 8320 GtkRadioMenuItemAccessiblePrivate* priv; 8321 } 8322 8323 struct GtkRadioMenuItemAccessibleClass 8324 { 8325 GtkCheckMenuItemAccessibleClass parentClass; 8326 } 8327 8328 struct GtkRadioMenuItemAccessiblePrivate; 8329 8330 struct GtkRadioMenuItemClass 8331 { 8332 GtkCheckMenuItemClass parentClass; 8333 /** */ 8334 extern(C) void function(GtkRadioMenuItem* radioMenuItem) groupChanged; 8335 /** */ 8336 extern(C) void function() GtkReserved1; 8337 /** */ 8338 extern(C) void function() GtkReserved2; 8339 /** */ 8340 extern(C) void function() GtkReserved3; 8341 /** */ 8342 extern(C) void function() GtkReserved4; 8343 } 8344 8345 struct GtkRadioMenuItemPrivate; 8346 8347 struct GtkRadioToolButton 8348 { 8349 GtkToggleToolButton parent; 8350 } 8351 8352 struct GtkRadioToolButtonClass 8353 { 8354 GtkToggleToolButtonClass parentClass; 8355 /** */ 8356 extern(C) void function() GtkReserved1; 8357 /** */ 8358 extern(C) void function() GtkReserved2; 8359 /** */ 8360 extern(C) void function() GtkReserved3; 8361 /** */ 8362 extern(C) void function() GtkReserved4; 8363 } 8364 8365 struct GtkRange 8366 { 8367 GtkWidget widget; 8368 GtkRangePrivate* priv; 8369 } 8370 8371 struct GtkRangeAccessible 8372 { 8373 GtkWidgetAccessible parent; 8374 GtkRangeAccessiblePrivate* priv; 8375 } 8376 8377 struct GtkRangeAccessibleClass 8378 { 8379 GtkWidgetAccessibleClass parentClass; 8380 } 8381 8382 struct GtkRangeAccessiblePrivate; 8383 8384 struct GtkRangeClass 8385 { 8386 GtkWidgetClass parentClass; 8387 char* sliderDetail; 8388 char* stepperDetail; 8389 /** */ 8390 extern(C) void function(GtkRange* range) valueChanged; 8391 /** */ 8392 extern(C) void function(GtkRange* range, double newValue) adjustBounds; 8393 /** */ 8394 extern(C) void function(GtkRange* range, GtkScrollType scroll) moveSlider; 8395 /** */ 8396 extern(C) void function(GtkRange* range, GtkBorder* border) getRangeBorder; 8397 /** */ 8398 extern(C) int function(GtkRange* range, GtkScrollType scroll, double newValue) changeValue; 8399 /** */ 8400 extern(C) void function(GtkRange* range, GtkOrientation orientation, int* minimum, int* natural) getRangeSizeRequest; 8401 /** */ 8402 extern(C) void function() GtkReserved1; 8403 /** */ 8404 extern(C) void function() GtkReserved2; 8405 /** */ 8406 extern(C) void function() GtkReserved3; 8407 } 8408 8409 struct GtkRangePrivate; 8410 8411 struct GtkRcContext; 8412 8413 /** 8414 * Deprecated 8415 */ 8416 struct GtkRcProperty 8417 { 8418 /** 8419 * quark-ified type identifier 8420 */ 8421 GQuark typeName; 8422 /** 8423 * quark-ified property identifier like 8424 * “GtkScrollbar::spacing” 8425 */ 8426 GQuark propertyName; 8427 /** 8428 * field similar to one found in #GtkSettingsValue 8429 */ 8430 char* origin; 8431 /** 8432 * field similar to one found in #GtkSettingsValue 8433 */ 8434 GValue value; 8435 } 8436 8437 struct GtkRcStyle 8438 { 8439 GObject parentInstance; 8440 /** 8441 * Name 8442 */ 8443 char* name; 8444 /** 8445 * Pixmap name 8446 */ 8447 char*[5] bgPixmapName; 8448 /** 8449 * A #PangoFontDescription 8450 */ 8451 PangoFontDescription* fontDesc; 8452 /** 8453 * #GtkRcFlags 8454 */ 8455 GtkRcFlags[5] colorFlags; 8456 /** 8457 * Foreground colors 8458 */ 8459 GdkColor[5] fg; 8460 /** 8461 * Background colors 8462 */ 8463 GdkColor[5] bg; 8464 /** 8465 * Text colors 8466 */ 8467 GdkColor[5] text; 8468 /** 8469 * Base colors 8470 */ 8471 GdkColor[5] base; 8472 /** 8473 * X thickness 8474 */ 8475 int xthickness; 8476 /** 8477 * Y thickness 8478 */ 8479 int ythickness; 8480 GArray* rcProperties; 8481 GSList* rcStyleLists; 8482 GSList* iconFactories; 8483 import std.bitmanip: bitfields; 8484 mixin(bitfields!( 8485 uint, "engineSpecified", 1, 8486 uint, "", 31 8487 )); 8488 } 8489 8490 struct GtkRcStyleClass 8491 { 8492 /** 8493 * The parent class. 8494 */ 8495 GObjectClass parentClass; 8496 /** */ 8497 extern(C) GtkRcStyle* function(GtkRcStyle* rcStyle) createRcStyle; 8498 /** */ 8499 extern(C) uint function(GtkRcStyle* rcStyle, GtkSettings* settings, GScanner* scanner) parse; 8500 /** */ 8501 extern(C) void function(GtkRcStyle* dest, GtkRcStyle* src) merge; 8502 /** */ 8503 extern(C) GtkStyle* function(GtkRcStyle* rcStyle) createStyle; 8504 /** */ 8505 extern(C) void function() GtkReserved1; 8506 /** */ 8507 extern(C) void function() GtkReserved2; 8508 /** */ 8509 extern(C) void function() GtkReserved3; 8510 /** */ 8511 extern(C) void function() GtkReserved4; 8512 } 8513 8514 struct GtkRecentAction 8515 { 8516 GtkAction parentInstance; 8517 GtkRecentActionPrivate* priv; 8518 } 8519 8520 struct GtkRecentActionClass 8521 { 8522 GtkActionClass parentClass; 8523 /** */ 8524 extern(C) void function() GtkReserved1; 8525 /** */ 8526 extern(C) void function() GtkReserved2; 8527 /** */ 8528 extern(C) void function() GtkReserved3; 8529 /** */ 8530 extern(C) void function() GtkReserved4; 8531 } 8532 8533 struct GtkRecentActionPrivate; 8534 8535 struct GtkRecentChooser; 8536 8537 struct GtkRecentChooserDialog 8538 { 8539 GtkDialog parentInstance; 8540 GtkRecentChooserDialogPrivate* priv; 8541 } 8542 8543 struct GtkRecentChooserDialogClass 8544 { 8545 GtkDialogClass parentClass; 8546 /** */ 8547 extern(C) void function() GtkReserved1; 8548 /** */ 8549 extern(C) void function() GtkReserved2; 8550 /** */ 8551 extern(C) void function() GtkReserved3; 8552 /** */ 8553 extern(C) void function() GtkReserved4; 8554 } 8555 8556 struct GtkRecentChooserDialogPrivate; 8557 8558 struct GtkRecentChooserIface 8559 { 8560 GTypeInterface baseIface; 8561 /** 8562 * 8563 * Params: 8564 * chooser = a #GtkRecentChooser 8565 * uri = a URI 8566 * Returns: %TRUE if the URI was found. 8567 * 8568 * Throws: GException on failure. 8569 */ 8570 extern(C) int function(GtkRecentChooser* chooser, const(char)* uri, GError** err) setCurrentUri; 8571 /** 8572 * 8573 * Params: 8574 * chooser = a #GtkRecentChooser 8575 * Returns: a newly allocated string holding a URI. 8576 */ 8577 extern(C) char* function(GtkRecentChooser* chooser) getCurrentUri; 8578 /** 8579 * 8580 * Params: 8581 * chooser = a #GtkRecentChooser 8582 * uri = a URI 8583 * Returns: %TRUE if @uri was found. 8584 * 8585 * Throws: GException on failure. 8586 */ 8587 extern(C) int function(GtkRecentChooser* chooser, const(char)* uri, GError** err) selectUri; 8588 /** */ 8589 extern(C) void function(GtkRecentChooser* chooser, const(char)* uri) unselectUri; 8590 /** */ 8591 extern(C) void function(GtkRecentChooser* chooser) selectAll; 8592 /** */ 8593 extern(C) void function(GtkRecentChooser* chooser) unselectAll; 8594 /** 8595 * 8596 * Params: 8597 * chooser = a #GtkRecentChooser 8598 * Returns: A newly allocated 8599 * list of #GtkRecentInfo objects. You should 8600 * use gtk_recent_info_unref() on every item of the list, and then free 8601 * the list itself using g_list_free(). 8602 */ 8603 extern(C) GList* function(GtkRecentChooser* chooser) getItems; 8604 /** */ 8605 extern(C) GtkRecentManager* function(GtkRecentChooser* chooser) getRecentManager; 8606 /** */ 8607 extern(C) void function(GtkRecentChooser* chooser, GtkRecentFilter* filter) addFilter; 8608 /** */ 8609 extern(C) void function(GtkRecentChooser* chooser, GtkRecentFilter* filter) removeFilter; 8610 /** 8611 * 8612 * Params: 8613 * chooser = a #GtkRecentChooser 8614 * Returns: A singly linked list 8615 * of #GtkRecentFilter objects. You 8616 * should just free the returned list using g_slist_free(). 8617 */ 8618 extern(C) GSList* function(GtkRecentChooser* chooser) listFilters; 8619 /** */ 8620 extern(C) void function(GtkRecentChooser* chooser, GtkRecentSortFunc sortFunc, void* sortData, GDestroyNotify dataDestroy) setSortFunc; 8621 /** */ 8622 extern(C) void function(GtkRecentChooser* chooser) itemActivated; 8623 /** */ 8624 extern(C) void function(GtkRecentChooser* chooser) selectionChanged; 8625 } 8626 8627 struct GtkRecentChooserMenu 8628 { 8629 GtkMenu parentInstance; 8630 GtkRecentChooserMenuPrivate* priv; 8631 } 8632 8633 struct GtkRecentChooserMenuClass 8634 { 8635 GtkMenuClass parentClass; 8636 /** */ 8637 extern(C) void function() gtkRecent1; 8638 /** */ 8639 extern(C) void function() gtkRecent2; 8640 /** */ 8641 extern(C) void function() gtkRecent3; 8642 /** */ 8643 extern(C) void function() gtkRecent4; 8644 } 8645 8646 struct GtkRecentChooserMenuPrivate; 8647 8648 struct GtkRecentChooserWidget 8649 { 8650 GtkBox parentInstance; 8651 GtkRecentChooserWidgetPrivate* priv; 8652 } 8653 8654 struct GtkRecentChooserWidgetClass 8655 { 8656 GtkBoxClass parentClass; 8657 /** */ 8658 extern(C) void function() GtkReserved1; 8659 /** */ 8660 extern(C) void function() GtkReserved2; 8661 /** */ 8662 extern(C) void function() GtkReserved3; 8663 /** */ 8664 extern(C) void function() GtkReserved4; 8665 } 8666 8667 struct GtkRecentChooserWidgetPrivate; 8668 8669 /** 8670 * Meta-data to be passed to gtk_recent_manager_add_full() when 8671 * registering a recently used resource. 8672 */ 8673 struct GtkRecentData 8674 { 8675 /** 8676 * a UTF-8 encoded string, containing the name of the recently 8677 * used resource to be displayed, or %NULL; 8678 */ 8679 char* displayName; 8680 /** 8681 * a UTF-8 encoded string, containing a short description of 8682 * the resource, or %NULL; 8683 */ 8684 char* description; 8685 /** 8686 * the MIME type of the resource; 8687 */ 8688 char* mimeType; 8689 /** 8690 * the name of the application that is registering this recently 8691 * used resource; 8692 */ 8693 char* appName; 8694 /** 8695 * command line used to launch this resource; may contain the 8696 * “\%f” and “\%u” escape characters which will be expanded 8697 * to the resource file path and URI respectively when the command line 8698 * is retrieved; 8699 */ 8700 char* appExec; 8701 /** 8702 * a vector of strings containing 8703 * groups names; 8704 */ 8705 char** groups; 8706 /** 8707 * whether this resource should be displayed only by the 8708 * applications that have registered it or not. 8709 */ 8710 bool isPrivate; 8711 } 8712 8713 struct GtkRecentFilter; 8714 8715 /** 8716 * A GtkRecentFilterInfo struct is used 8717 * to pass information about the tested file to gtk_recent_filter_filter(). 8718 */ 8719 struct GtkRecentFilterInfo 8720 { 8721 /** 8722 * #GtkRecentFilterFlags to indicate which fields are set. 8723 */ 8724 GtkRecentFilterFlags contains; 8725 /** 8726 * The URI of the file being tested. 8727 */ 8728 const(char)* uri; 8729 /** 8730 * The string that will be used to display 8731 * the file in the recent chooser. 8732 */ 8733 const(char)* displayName; 8734 /** 8735 * MIME type of the file. 8736 */ 8737 const(char)* mimeType; 8738 /** 8739 * The list of 8740 * applications that have registered the file. 8741 */ 8742 char** applications; 8743 /** 8744 * The groups to which 8745 * the file belongs to. 8746 */ 8747 char** groups; 8748 /** 8749 * The number of days elapsed since the file has been 8750 * registered. 8751 */ 8752 int age; 8753 } 8754 8755 struct GtkRecentInfo; 8756 8757 struct GtkRecentManager 8758 { 8759 GObject parentInstance; 8760 GtkRecentManagerPrivate* priv; 8761 } 8762 8763 /** 8764 * #GtkRecentManagerClass contains only private data. 8765 * 8766 * Since: 2.10 8767 */ 8768 struct GtkRecentManagerClass 8769 { 8770 GObjectClass parentClass; 8771 /** */ 8772 extern(C) void function(GtkRecentManager* manager) changed; 8773 /** */ 8774 extern(C) void function() GtkRecent1; 8775 /** */ 8776 extern(C) void function() GtkRecent2; 8777 /** */ 8778 extern(C) void function() GtkRecent3; 8779 /** */ 8780 extern(C) void function() GtkRecent4; 8781 } 8782 8783 struct GtkRecentManagerPrivate; 8784 8785 struct GtkRendererCellAccessible 8786 { 8787 GtkCellAccessible parent; 8788 GtkRendererCellAccessiblePrivate* priv; 8789 } 8790 8791 struct GtkRendererCellAccessibleClass 8792 { 8793 GtkCellAccessibleClass parentClass; 8794 } 8795 8796 struct GtkRendererCellAccessiblePrivate; 8797 8798 /** 8799 * Represents a request of a screen object in a given orientation. These 8800 * are primarily used in container implementations when allocating a natural 8801 * size for children calling. See gtk_distribute_natural_allocation(). 8802 */ 8803 struct GtkRequestedSize 8804 { 8805 /** 8806 * A client pointer 8807 */ 8808 void* data; 8809 /** 8810 * The minimum size needed for allocation in a given orientation 8811 */ 8812 int minimumSize; 8813 /** 8814 * The natural size for allocation in a given orientation 8815 */ 8816 int naturalSize; 8817 } 8818 8819 struct GtkRequisition 8820 { 8821 /** 8822 * the widget’s desired width 8823 */ 8824 int width; 8825 /** 8826 * the widget’s desired height 8827 */ 8828 int height; 8829 } 8830 8831 struct GtkRevealer 8832 { 8833 GtkBin parentInstance; 8834 } 8835 8836 struct GtkRevealerClass 8837 { 8838 /** 8839 * The parent class. 8840 */ 8841 GtkBinClass parentClass; 8842 } 8843 8844 struct GtkScale 8845 { 8846 GtkRange range; 8847 GtkScalePrivate* priv; 8848 } 8849 8850 struct GtkScaleAccessible 8851 { 8852 GtkRangeAccessible parent; 8853 GtkScaleAccessiblePrivate* priv; 8854 } 8855 8856 struct GtkScaleAccessibleClass 8857 { 8858 GtkRangeAccessibleClass parentClass; 8859 } 8860 8861 struct GtkScaleAccessiblePrivate; 8862 8863 struct GtkScaleButton 8864 { 8865 GtkButton parent; 8866 GtkScaleButtonPrivate* priv; 8867 } 8868 8869 struct GtkScaleButtonAccessible 8870 { 8871 GtkButtonAccessible parent; 8872 GtkScaleButtonAccessiblePrivate* priv; 8873 } 8874 8875 struct GtkScaleButtonAccessibleClass 8876 { 8877 GtkButtonAccessibleClass parentClass; 8878 } 8879 8880 struct GtkScaleButtonAccessiblePrivate; 8881 8882 struct GtkScaleButtonClass 8883 { 8884 GtkButtonClass parentClass; 8885 /** */ 8886 extern(C) void function(GtkScaleButton* button, double value) valueChanged; 8887 /** */ 8888 extern(C) void function() GtkReserved1; 8889 /** */ 8890 extern(C) void function() GtkReserved2; 8891 /** */ 8892 extern(C) void function() GtkReserved3; 8893 /** */ 8894 extern(C) void function() GtkReserved4; 8895 } 8896 8897 struct GtkScaleButtonPrivate; 8898 8899 struct GtkScaleClass 8900 { 8901 GtkRangeClass parentClass; 8902 /** */ 8903 extern(C) char* function(GtkScale* scale, double value) formatValue; 8904 /** */ 8905 extern(C) void function(GtkScale* scale) drawValue; 8906 /** */ 8907 extern(C) void function(GtkScale* scale, int* x, int* y) getLayoutOffsets; 8908 /** */ 8909 extern(C) void function() GtkReserved1; 8910 /** */ 8911 extern(C) void function() GtkReserved2; 8912 /** */ 8913 extern(C) void function() GtkReserved3; 8914 /** */ 8915 extern(C) void function() GtkReserved4; 8916 } 8917 8918 struct GtkScalePrivate; 8919 8920 struct GtkScrollable; 8921 8922 struct GtkScrollableInterface 8923 { 8924 GTypeInterface baseIface; 8925 /** 8926 * 8927 * Params: 8928 * scrollable = a #GtkScrollable 8929 * border = return location for the results 8930 * Returns: %TRUE if @border has been set 8931 */ 8932 extern(C) int function(GtkScrollable* scrollable, GtkBorder* border) getBorder; 8933 } 8934 8935 struct GtkScrollbar 8936 { 8937 GtkRange range; 8938 } 8939 8940 struct GtkScrollbarClass 8941 { 8942 GtkRangeClass parentClass; 8943 /** */ 8944 extern(C) void function() GtkReserved1; 8945 /** */ 8946 extern(C) void function() GtkReserved2; 8947 /** */ 8948 extern(C) void function() GtkReserved3; 8949 /** */ 8950 extern(C) void function() GtkReserved4; 8951 } 8952 8953 struct GtkScrolledWindow 8954 { 8955 GtkBin container; 8956 GtkScrolledWindowPrivate* priv; 8957 } 8958 8959 struct GtkScrolledWindowAccessible 8960 { 8961 GtkContainerAccessible parent; 8962 GtkScrolledWindowAccessiblePrivate* priv; 8963 } 8964 8965 struct GtkScrolledWindowAccessibleClass 8966 { 8967 GtkContainerAccessibleClass parentClass; 8968 } 8969 8970 struct GtkScrolledWindowAccessiblePrivate; 8971 8972 struct GtkScrolledWindowClass 8973 { 8974 /** 8975 * The parent class. 8976 */ 8977 GtkBinClass parentClass; 8978 int scrollbarSpacing; 8979 /** */ 8980 extern(C) int function(GtkScrolledWindow* scrolledWindow, GtkScrollType scroll, int horizontal) scrollChild; 8981 /** */ 8982 extern(C) void function(GtkScrolledWindow* scrolledWindow, GtkDirectionType direction) moveFocusOut; 8983 /** */ 8984 extern(C) void function() GtkReserved1; 8985 /** */ 8986 extern(C) void function() GtkReserved2; 8987 /** */ 8988 extern(C) void function() GtkReserved3; 8989 /** */ 8990 extern(C) void function() GtkReserved4; 8991 } 8992 8993 struct GtkScrolledWindowPrivate; 8994 8995 struct GtkSearchBar 8996 { 8997 GtkBin parent; 8998 } 8999 9000 struct GtkSearchBarClass 9001 { 9002 /** 9003 * The parent class. 9004 */ 9005 GtkBinClass parentClass; 9006 /** */ 9007 extern(C) void function() GtkReserved1; 9008 /** */ 9009 extern(C) void function() GtkReserved2; 9010 /** */ 9011 extern(C) void function() GtkReserved3; 9012 /** */ 9013 extern(C) void function() GtkReserved4; 9014 } 9015 9016 struct GtkSearchEntry 9017 { 9018 GtkEntry parent; 9019 } 9020 9021 struct GtkSearchEntryClass 9022 { 9023 GtkEntryClass parentClass; 9024 /** */ 9025 extern(C) void function(GtkSearchEntry* entry) searchChanged; 9026 /** */ 9027 extern(C) void function(GtkSearchEntry* entry) nextMatch; 9028 /** */ 9029 extern(C) void function(GtkSearchEntry* entry) previousMatch; 9030 /** */ 9031 extern(C) void function(GtkSearchEntry* entry) stopSearch; 9032 } 9033 9034 struct GtkSelectionData; 9035 9036 struct GtkSeparator 9037 { 9038 GtkWidget widget; 9039 GtkSeparatorPrivate* priv; 9040 } 9041 9042 struct GtkSeparatorClass 9043 { 9044 GtkWidgetClass parentClass; 9045 /** */ 9046 extern(C) void function() GtkReserved1; 9047 /** */ 9048 extern(C) void function() GtkReserved2; 9049 /** */ 9050 extern(C) void function() GtkReserved3; 9051 /** */ 9052 extern(C) void function() GtkReserved4; 9053 } 9054 9055 struct GtkSeparatorMenuItem 9056 { 9057 GtkMenuItem menuItem; 9058 } 9059 9060 struct GtkSeparatorMenuItemClass 9061 { 9062 /** 9063 * The parent class. 9064 */ 9065 GtkMenuItemClass parentClass; 9066 /** */ 9067 extern(C) void function() GtkReserved1; 9068 /** */ 9069 extern(C) void function() GtkReserved2; 9070 /** */ 9071 extern(C) void function() GtkReserved3; 9072 /** */ 9073 extern(C) void function() GtkReserved4; 9074 } 9075 9076 struct GtkSeparatorPrivate; 9077 9078 struct GtkSeparatorToolItem 9079 { 9080 GtkToolItem parent; 9081 GtkSeparatorToolItemPrivate* priv; 9082 } 9083 9084 struct GtkSeparatorToolItemClass 9085 { 9086 /** 9087 * The parent class. 9088 */ 9089 GtkToolItemClass parentClass; 9090 /** */ 9091 extern(C) void function() GtkReserved1; 9092 /** */ 9093 extern(C) void function() GtkReserved2; 9094 /** */ 9095 extern(C) void function() GtkReserved3; 9096 /** */ 9097 extern(C) void function() GtkReserved4; 9098 } 9099 9100 struct GtkSeparatorToolItemPrivate; 9101 9102 struct GtkSettings 9103 { 9104 GObject parentInstance; 9105 GtkSettingsPrivate* priv; 9106 } 9107 9108 struct GtkSettingsClass 9109 { 9110 GObjectClass parentClass; 9111 /** */ 9112 extern(C) void function() GtkReserved1; 9113 /** */ 9114 extern(C) void function() GtkReserved2; 9115 /** */ 9116 extern(C) void function() GtkReserved3; 9117 /** */ 9118 extern(C) void function() GtkReserved4; 9119 } 9120 9121 struct GtkSettingsPrivate; 9122 9123 struct GtkSettingsValue 9124 { 9125 /** 9126 * Origin should be something like “filename:linenumber” for 9127 * rc files, or e.g. “XProperty” for other sources. 9128 */ 9129 char* origin; 9130 /** 9131 * Valid types are LONG, DOUBLE and STRING corresponding to 9132 * the token parsed, or a GSTRING holding an unparsed statement 9133 */ 9134 GValue value; 9135 } 9136 9137 struct GtkShortcutLabel; 9138 9139 struct GtkShortcutLabelClass; 9140 9141 struct GtkShortcutsGroup; 9142 9143 struct GtkShortcutsGroupClass; 9144 9145 struct GtkShortcutsSection; 9146 9147 struct GtkShortcutsSectionClass; 9148 9149 struct GtkShortcutsShortcut; 9150 9151 struct GtkShortcutsShortcutClass; 9152 9153 struct GtkShortcutsWindow 9154 { 9155 GtkWindow window; 9156 } 9157 9158 struct GtkShortcutsWindowClass 9159 { 9160 GtkWindowClass parentClass; 9161 /** */ 9162 extern(C) void function(GtkShortcutsWindow* self) close; 9163 /** */ 9164 extern(C) void function(GtkShortcutsWindow* self) search; 9165 } 9166 9167 struct GtkSizeGroup 9168 { 9169 GObject parentInstance; 9170 GtkSizeGroupPrivate* priv; 9171 } 9172 9173 struct GtkSizeGroupClass 9174 { 9175 GObjectClass parentClass; 9176 /** */ 9177 extern(C) void function() GtkReserved1; 9178 /** */ 9179 extern(C) void function() GtkReserved2; 9180 /** */ 9181 extern(C) void function() GtkReserved3; 9182 /** */ 9183 extern(C) void function() GtkReserved4; 9184 } 9185 9186 struct GtkSizeGroupPrivate; 9187 9188 struct GtkSocket 9189 { 9190 GtkContainer container; 9191 GtkSocketPrivate* priv; 9192 } 9193 9194 struct GtkSocketClass 9195 { 9196 GtkContainerClass parentClass; 9197 /** */ 9198 extern(C) void function(GtkSocket* socket) plugAdded; 9199 /** */ 9200 extern(C) int function(GtkSocket* socket) plugRemoved; 9201 /** */ 9202 extern(C) void function() GtkReserved1; 9203 /** */ 9204 extern(C) void function() GtkReserved2; 9205 /** */ 9206 extern(C) void function() GtkReserved3; 9207 /** */ 9208 extern(C) void function() GtkReserved4; 9209 } 9210 9211 struct GtkSocketPrivate; 9212 9213 struct GtkSpinButton 9214 { 9215 GtkEntry entry; 9216 GtkSpinButtonPrivate* priv; 9217 } 9218 9219 struct GtkSpinButtonAccessible 9220 { 9221 GtkEntryAccessible parent; 9222 GtkSpinButtonAccessiblePrivate* priv; 9223 } 9224 9225 struct GtkSpinButtonAccessibleClass 9226 { 9227 GtkEntryAccessibleClass parentClass; 9228 } 9229 9230 struct GtkSpinButtonAccessiblePrivate; 9231 9232 struct GtkSpinButtonClass 9233 { 9234 GtkEntryClass parentClass; 9235 /** */ 9236 extern(C) int function(GtkSpinButton* spinButton, double* newValue) input; 9237 /** */ 9238 extern(C) int function(GtkSpinButton* spinButton) output; 9239 /** */ 9240 extern(C) void function(GtkSpinButton* spinButton) valueChanged; 9241 /** */ 9242 extern(C) void function(GtkSpinButton* spinButton, GtkScrollType scroll) changeValue; 9243 /** */ 9244 extern(C) void function(GtkSpinButton* spinButton) wrapped; 9245 /** */ 9246 extern(C) void function() GtkReserved1; 9247 /** */ 9248 extern(C) void function() GtkReserved2; 9249 /** */ 9250 extern(C) void function() GtkReserved3; 9251 /** */ 9252 extern(C) void function() GtkReserved4; 9253 } 9254 9255 struct GtkSpinButtonPrivate; 9256 9257 struct GtkSpinner 9258 { 9259 GtkWidget parent; 9260 GtkSpinnerPrivate* priv; 9261 } 9262 9263 struct GtkSpinnerAccessible 9264 { 9265 GtkWidgetAccessible parent; 9266 GtkSpinnerAccessiblePrivate* priv; 9267 } 9268 9269 struct GtkSpinnerAccessibleClass 9270 { 9271 GtkWidgetAccessibleClass parentClass; 9272 } 9273 9274 struct GtkSpinnerAccessiblePrivate; 9275 9276 struct GtkSpinnerClass 9277 { 9278 GtkWidgetClass parentClass; 9279 /** */ 9280 extern(C) void function() GtkReserved1; 9281 /** */ 9282 extern(C) void function() GtkReserved2; 9283 /** */ 9284 extern(C) void function() GtkReserved3; 9285 /** */ 9286 extern(C) void function() GtkReserved4; 9287 } 9288 9289 struct GtkSpinnerPrivate; 9290 9291 struct GtkStack 9292 { 9293 GtkContainer parentInstance; 9294 } 9295 9296 struct GtkStackAccessible 9297 { 9298 GtkContainerAccessible parent; 9299 } 9300 9301 struct GtkStackAccessibleClass 9302 { 9303 GtkContainerAccessibleClass parentClass; 9304 } 9305 9306 struct GtkStackClass 9307 { 9308 GtkContainerClass parentClass; 9309 } 9310 9311 struct GtkStackSidebar 9312 { 9313 GtkBin parent; 9314 } 9315 9316 struct GtkStackSidebarClass 9317 { 9318 GtkBinClass parentClass; 9319 /** */ 9320 extern(C) void function() GtkReserved1; 9321 /** */ 9322 extern(C) void function() GtkReserved2; 9323 /** */ 9324 extern(C) void function() GtkReserved3; 9325 /** */ 9326 extern(C) void function() GtkReserved4; 9327 } 9328 9329 struct GtkStackSidebarPrivate; 9330 9331 struct GtkStackSwitcher 9332 { 9333 GtkBox widget; 9334 } 9335 9336 struct GtkStackSwitcherClass 9337 { 9338 GtkBoxClass parentClass; 9339 /** */ 9340 extern(C) void function() GtkReserved1; 9341 /** */ 9342 extern(C) void function() GtkReserved2; 9343 /** */ 9344 extern(C) void function() GtkReserved3; 9345 /** */ 9346 extern(C) void function() GtkReserved4; 9347 } 9348 9349 struct GtkStatusIcon 9350 { 9351 GObject parentInstance; 9352 GtkStatusIconPrivate* priv; 9353 } 9354 9355 struct GtkStatusIconClass 9356 { 9357 GObjectClass parentClass; 9358 /** */ 9359 extern(C) void function(GtkStatusIcon* statusIcon) activate; 9360 /** */ 9361 extern(C) void function(GtkStatusIcon* statusIcon, uint button, uint activateTime) popupMenu; 9362 /** */ 9363 extern(C) int function(GtkStatusIcon* statusIcon, int size) sizeChanged; 9364 /** */ 9365 extern(C) int function(GtkStatusIcon* statusIcon, GdkEventButton* event) buttonPressEvent; 9366 /** */ 9367 extern(C) int function(GtkStatusIcon* statusIcon, GdkEventButton* event) buttonReleaseEvent; 9368 /** */ 9369 extern(C) int function(GtkStatusIcon* statusIcon, GdkEventScroll* event) scrollEvent; 9370 /** */ 9371 extern(C) int function(GtkStatusIcon* statusIcon, int x, int y, int keyboardMode, GtkTooltip* tooltip) queryTooltip; 9372 void* GtkReserved1; 9373 void* GtkReserved2; 9374 void* GtkReserved3; 9375 void* GtkReserved4; 9376 } 9377 9378 struct GtkStatusIconPrivate; 9379 9380 struct GtkStatusbar 9381 { 9382 GtkBox parentWidget; 9383 GtkStatusbarPrivate* priv; 9384 } 9385 9386 struct GtkStatusbarAccessible 9387 { 9388 GtkContainerAccessible parent; 9389 GtkStatusbarAccessiblePrivate* priv; 9390 } 9391 9392 struct GtkStatusbarAccessibleClass 9393 { 9394 GtkContainerAccessibleClass parentClass; 9395 } 9396 9397 struct GtkStatusbarAccessiblePrivate; 9398 9399 struct GtkStatusbarClass 9400 { 9401 GtkBoxClass parentClass; 9402 void* reserved; 9403 /** */ 9404 extern(C) void function(GtkStatusbar* statusbar, uint contextId, const(char)* text) textPushed; 9405 /** */ 9406 extern(C) void function(GtkStatusbar* statusbar, uint contextId, const(char)* text) textPopped; 9407 /** */ 9408 extern(C) void function() GtkReserved1; 9409 /** */ 9410 extern(C) void function() GtkReserved2; 9411 /** */ 9412 extern(C) void function() GtkReserved3; 9413 /** */ 9414 extern(C) void function() GtkReserved4; 9415 } 9416 9417 struct GtkStatusbarPrivate; 9418 9419 struct GtkStockItem 9420 { 9421 /** 9422 * Identifier. 9423 */ 9424 char* stockId; 9425 /** 9426 * User visible label. 9427 */ 9428 char* label; 9429 /** 9430 * Modifier type for keyboard accelerator 9431 */ 9432 GdkModifierType modifier; 9433 /** 9434 * Keyboard accelerator 9435 */ 9436 uint keyval; 9437 /** 9438 * Translation domain of the menu or toolbar item 9439 */ 9440 char* translationDomain; 9441 } 9442 9443 struct GtkStyle 9444 { 9445 GObject parentInstance; 9446 /** 9447 * Set of foreground #GdkColor 9448 */ 9449 GdkColor[5] fg; 9450 /** 9451 * Set of background #GdkColor 9452 */ 9453 GdkColor[5] bg; 9454 /** 9455 * Set of light #GdkColor 9456 */ 9457 GdkColor[5] light; 9458 /** 9459 * Set of dark #GdkColor 9460 */ 9461 GdkColor[5] dark; 9462 /** 9463 * Set of mid #GdkColor 9464 */ 9465 GdkColor[5] mid; 9466 /** 9467 * Set of text #GdkColor 9468 */ 9469 GdkColor[5] text; 9470 /** 9471 * Set of base #GdkColor 9472 */ 9473 GdkColor[5] base; 9474 /** 9475 * Color halfway between text/base 9476 */ 9477 GdkColor[5] textAa; 9478 /** 9479 * #GdkColor to use for black 9480 */ 9481 GdkColor black; 9482 /** 9483 * #GdkColor to use for white 9484 */ 9485 GdkColor white; 9486 /** 9487 * #PangoFontDescription 9488 */ 9489 PangoFontDescription* fontDesc; 9490 /** 9491 * Thickness in X direction 9492 */ 9493 int xthickness; 9494 /** 9495 * Thickness in Y direction 9496 */ 9497 int ythickness; 9498 /** 9499 * Set of background #cairo_pattern_t 9500 */ 9501 cairo_pattern_t*[5] background; 9502 int attachCount; 9503 GdkVisual* visual; 9504 PangoFontDescription* privateFontDesc; 9505 GtkRcStyle* rcStyle; 9506 GSList* styles; 9507 GArray* propertyCache; 9508 GSList* iconFactories; 9509 } 9510 9511 struct GtkStyleClass 9512 { 9513 /** 9514 * The parent class. 9515 */ 9516 GObjectClass parentClass; 9517 /** */ 9518 extern(C) void function(GtkStyle* style) realize; 9519 /** */ 9520 extern(C) void function(GtkStyle* style) unrealize; 9521 /** */ 9522 extern(C) void function(GtkStyle* style, GtkStyle* src) copy; 9523 /** */ 9524 extern(C) GtkStyle* function(GtkStyle* style) clone; 9525 /** */ 9526 extern(C) void function(GtkStyle* style, GtkRcStyle* rcStyle) initFromRc; 9527 /** */ 9528 extern(C) void function(GtkStyle* style, GdkWindow* window, GtkStateType stateType) setBackground; 9529 /** 9530 * 9531 * Params: 9532 * style = a #GtkStyle 9533 * source = the #GtkIconSource specifying the icon to render 9534 * direction = a text direction 9535 * state = a state 9536 * size = the size to render the icon at (#GtkIconSize). A size of 9537 * `(GtkIconSize)-1` means render at the size of the source and 9538 * don’t scale. 9539 * widget = the widget 9540 * detail = a style detail 9541 * Returns: a newly-created #GdkPixbuf 9542 * containing the rendered icon 9543 */ 9544 extern(C) GdkPixbuf* function(GtkStyle* style, GtkIconSource* source, GtkTextDirection direction, GtkStateType state, GtkIconSize size, GtkWidget* widget, const(char)* detail) renderIcon; 9545 /** */ 9546 extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkWidget* widget, const(char)* detail, int x1, int x2, int y) drawHline; 9547 /** */ 9548 extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkWidget* widget, const(char)* detail, int y1, int y2, int x) drawVline; 9549 /** */ 9550 extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkShadowType shadowType, GtkWidget* widget, const(char)* detail, int x, int y, int width, int height) drawShadow; 9551 /** */ 9552 extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkShadowType shadowType, GtkWidget* widget, const(char)* detail, GtkArrowType arrowType, int fill, int x, int y, int width, int height) drawArrow; 9553 /** */ 9554 extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkShadowType shadowType, GtkWidget* widget, const(char)* detail, int x, int y, int width, int height) drawDiamond; 9555 /** */ 9556 extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkShadowType shadowType, GtkWidget* widget, const(char)* detail, int x, int y, int width, int height) drawBox; 9557 /** */ 9558 extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkShadowType shadowType, GtkWidget* widget, const(char)* detail, int x, int y, int width, int height) drawFlatBox; 9559 /** */ 9560 extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkShadowType shadowType, GtkWidget* widget, const(char)* detail, int x, int y, int width, int height) drawCheck; 9561 /** */ 9562 extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkShadowType shadowType, GtkWidget* widget, const(char)* detail, int x, int y, int width, int height) drawOption; 9563 /** */ 9564 extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkShadowType shadowType, GtkWidget* widget, const(char)* detail, int x, int y, int width, int height) drawTab; 9565 /** */ 9566 extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkShadowType shadowType, GtkWidget* widget, const(char)* detail, int x, int y, int width, int height, GtkPositionType gapSide, int gapX, int gapWidth) drawShadowGap; 9567 /** */ 9568 extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkShadowType shadowType, GtkWidget* widget, const(char)* detail, int x, int y, int width, int height, GtkPositionType gapSide, int gapX, int gapWidth) drawBoxGap; 9569 /** */ 9570 extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkShadowType shadowType, GtkWidget* widget, const(char)* detail, int x, int y, int width, int height, GtkPositionType gapSide) drawExtension; 9571 /** */ 9572 extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkWidget* widget, const(char)* detail, int x, int y, int width, int height) drawFocus; 9573 /** */ 9574 extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkShadowType shadowType, GtkWidget* widget, const(char)* detail, int x, int y, int width, int height, GtkOrientation orientation) drawSlider; 9575 /** */ 9576 extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkShadowType shadowType, GtkWidget* widget, const(char)* detail, int x, int y, int width, int height, GtkOrientation orientation) drawHandle; 9577 /** */ 9578 extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkWidget* widget, const(char)* detail, int x, int y, GtkExpanderStyle expanderStyle) drawExpander; 9579 /** */ 9580 extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, int useText, GtkWidget* widget, const(char)* detail, int x, int y, PangoLayout* layout) drawLayout; 9581 /** */ 9582 extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkWidget* widget, const(char)* detail, GdkWindowEdge edge, int x, int y, int width, int height) drawResizeGrip; 9583 /** */ 9584 extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkWidget* widget, const(char)* detail, uint step, int x, int y, int width, int height) drawSpinner; 9585 /** */ 9586 extern(C) void function() GtkReserved1; 9587 /** */ 9588 extern(C) void function() GtkReserved2; 9589 /** */ 9590 extern(C) void function() GtkReserved3; 9591 /** */ 9592 extern(C) void function() GtkReserved4; 9593 /** */ 9594 extern(C) void function() GtkReserved5; 9595 /** */ 9596 extern(C) void function() GtkReserved6; 9597 /** */ 9598 extern(C) void function() GtkReserved7; 9599 /** */ 9600 extern(C) void function() GtkReserved8; 9601 /** */ 9602 extern(C) void function() GtkReserved9; 9603 /** */ 9604 extern(C) void function() GtkReserved10; 9605 /** */ 9606 extern(C) void function() GtkReserved11; 9607 } 9608 9609 struct GtkStyleContext 9610 { 9611 GObject parentObject; 9612 GtkStyleContextPrivate* priv; 9613 } 9614 9615 struct GtkStyleContextClass 9616 { 9617 GObjectClass parentClass; 9618 /** */ 9619 extern(C) void function(GtkStyleContext* context) changed; 9620 /** */ 9621 extern(C) void function() GtkReserved1; 9622 /** */ 9623 extern(C) void function() GtkReserved2; 9624 /** */ 9625 extern(C) void function() GtkReserved3; 9626 /** */ 9627 extern(C) void function() GtkReserved4; 9628 } 9629 9630 struct GtkStyleContextPrivate; 9631 9632 struct GtkStyleProperties 9633 { 9634 GObject parentObject; 9635 GtkStylePropertiesPrivate* priv; 9636 } 9637 9638 struct GtkStylePropertiesClass 9639 { 9640 GObjectClass parentClass; 9641 /** */ 9642 extern(C) void function() GtkReserved1; 9643 /** */ 9644 extern(C) void function() GtkReserved2; 9645 /** */ 9646 extern(C) void function() GtkReserved3; 9647 /** */ 9648 extern(C) void function() GtkReserved4; 9649 } 9650 9651 struct GtkStylePropertiesPrivate; 9652 9653 struct GtkStyleProvider; 9654 9655 struct GtkStyleProviderIface 9656 { 9657 GTypeInterface gIface; 9658 /** 9659 * 9660 * Params: 9661 * provider = a #GtkStyleProvider 9662 * path = #GtkWidgetPath to query 9663 * Returns: a #GtkStyleProperties containing the 9664 * style settings affecting @path 9665 */ 9666 extern(C) GtkStyleProperties* function(GtkStyleProvider* provider, GtkWidgetPath* path) getStyle; 9667 /** 9668 * 9669 * Params: 9670 * provider = a #GtkStyleProvider 9671 * path = #GtkWidgetPath to query 9672 * state = state to query the style property for 9673 * pspec = The #GParamSpec to query 9674 * value = return location for the property value 9675 * Returns: %TRUE if the property was found and has a value, %FALSE otherwise 9676 */ 9677 extern(C) int function(GtkStyleProvider* provider, GtkWidgetPath* path, GtkStateFlags state, GParamSpec* pspec, GValue* value) getStyleProperty; 9678 /** 9679 * 9680 * Params: 9681 * provider = a #GtkStyleProvider 9682 * path = #GtkWidgetPath to query 9683 * Returns: The icon factory to use for @path, or %NULL 9684 */ 9685 extern(C) GtkIconFactory* function(GtkStyleProvider* provider, GtkWidgetPath* path) getIconFactory; 9686 } 9687 9688 struct GtkSwitch 9689 { 9690 GtkWidget parentInstance; 9691 GtkSwitchPrivate* priv; 9692 } 9693 9694 struct GtkSwitchAccessible 9695 { 9696 GtkWidgetAccessible parent; 9697 GtkSwitchAccessiblePrivate* priv; 9698 } 9699 9700 struct GtkSwitchAccessibleClass 9701 { 9702 GtkWidgetAccessibleClass parentClass; 9703 } 9704 9705 struct GtkSwitchAccessiblePrivate; 9706 9707 struct GtkSwitchClass 9708 { 9709 /** 9710 * The parent class. 9711 */ 9712 GtkWidgetClass parentClass; 9713 /** */ 9714 extern(C) void function(GtkSwitch* sw) activate; 9715 /** */ 9716 extern(C) int function(GtkSwitch* sw, int state) stateSet; 9717 /** */ 9718 extern(C) void function() SwitchPadding1; 9719 /** */ 9720 extern(C) void function() SwitchPadding2; 9721 /** */ 9722 extern(C) void function() SwitchPadding3; 9723 /** */ 9724 extern(C) void function() SwitchPadding4; 9725 /** */ 9726 extern(C) void function() SwitchPadding5; 9727 } 9728 9729 struct GtkSwitchPrivate; 9730 9731 struct GtkSymbolicColor; 9732 9733 struct GtkTable 9734 { 9735 GtkContainer container; 9736 GtkTablePrivate* priv; 9737 } 9738 9739 struct GtkTableChild 9740 { 9741 GtkWidget* widget; 9742 ushort leftAttach; 9743 ushort rightAttach; 9744 ushort topAttach; 9745 ushort bottomAttach; 9746 ushort xpadding; 9747 ushort ypadding; 9748 import std.bitmanip: bitfields; 9749 mixin(bitfields!( 9750 uint, "xexpand", 1, 9751 uint, "yexpand", 1, 9752 uint, "xshrink", 1, 9753 uint, "yshrink", 1, 9754 uint, "xfill", 1, 9755 uint, "yfill", 1, 9756 uint, "", 26 9757 )); 9758 } 9759 9760 struct GtkTableClass 9761 { 9762 GtkContainerClass parentClass; 9763 /** */ 9764 extern(C) void function() GtkReserved1; 9765 /** */ 9766 extern(C) void function() GtkReserved2; 9767 /** */ 9768 extern(C) void function() GtkReserved3; 9769 /** */ 9770 extern(C) void function() GtkReserved4; 9771 } 9772 9773 struct GtkTablePrivate; 9774 9775 struct GtkTableRowCol 9776 { 9777 ushort requisition; 9778 ushort allocation; 9779 ushort spacing; 9780 import std.bitmanip: bitfields; 9781 mixin(bitfields!( 9782 uint, "needExpand", 1, 9783 uint, "needShrink", 1, 9784 uint, "expand", 1, 9785 uint, "shrink", 1, 9786 uint, "empty", 1, 9787 uint, "", 27 9788 )); 9789 } 9790 9791 struct GtkTargetEntry 9792 { 9793 /** 9794 * a string representation of the target type 9795 */ 9796 char* target; 9797 /** 9798 * #GtkTargetFlags for DND 9799 */ 9800 uint flags; 9801 /** 9802 * an application-assigned integer ID which will 9803 * get passed as a parameter to e.g the #GtkWidget::selection-get 9804 * signal. It allows the application to identify the target 9805 * type without extensive string compares. 9806 */ 9807 uint info; 9808 } 9809 9810 struct GtkTargetList; 9811 9812 /** 9813 * A #GtkTargetPair is used to represent the same 9814 * information as a table of #GtkTargetEntry, but in 9815 * an efficient form. 9816 */ 9817 struct GtkTargetPair 9818 { 9819 /** 9820 * #GdkAtom representation of the target type 9821 */ 9822 GdkAtom target; 9823 /** 9824 * #GtkTargetFlags for DND 9825 */ 9826 uint flags; 9827 /** 9828 * an application-assigned integer ID which will 9829 * get passed as a parameter to e.g the #GtkWidget::selection-get 9830 * signal. It allows the application to identify the target 9831 * type without extensive string compares. 9832 */ 9833 uint info; 9834 } 9835 9836 struct GtkTearoffMenuItem 9837 { 9838 GtkMenuItem menuItem; 9839 GtkTearoffMenuItemPrivate* priv; 9840 } 9841 9842 struct GtkTearoffMenuItemClass 9843 { 9844 /** 9845 * The parent class. 9846 */ 9847 GtkMenuItemClass parentClass; 9848 /** */ 9849 extern(C) void function() GtkReserved1; 9850 /** */ 9851 extern(C) void function() GtkReserved2; 9852 /** */ 9853 extern(C) void function() GtkReserved3; 9854 /** */ 9855 extern(C) void function() GtkReserved4; 9856 } 9857 9858 struct GtkTearoffMenuItemPrivate; 9859 9860 struct GtkTextAppearance 9861 { 9862 /** 9863 * Background #GdkColor. 9864 */ 9865 GdkColor bgColor; 9866 /** 9867 * Foreground #GdkColor. 9868 */ 9869 GdkColor fgColor; 9870 /** 9871 * Super/subscript rise, can be negative. 9872 */ 9873 int rise; 9874 import std.bitmanip: bitfields; 9875 mixin(bitfields!( 9876 uint, "underline", 4, 9877 uint, "strikethrough", 1, 9878 uint, "drawBg", 1, 9879 uint, "insideSelection", 1, 9880 uint, "isText", 1, 9881 uint, "", 24 9882 )); 9883 union 9884 { 9885 GdkRGBA*[2] rgba; 9886 uint[4] padding; 9887 } 9888 } 9889 9890 struct GtkTextAttributes 9891 { 9892 uint refcount; 9893 /** 9894 * #GtkTextAppearance for text. 9895 */ 9896 GtkTextAppearance appearance; 9897 /** 9898 * #GtkJustification for text. 9899 */ 9900 GtkJustification justification; 9901 /** 9902 * #GtkTextDirection for text. 9903 */ 9904 GtkTextDirection direction; 9905 /** 9906 * #PangoFontDescription for text. 9907 */ 9908 PangoFontDescription* font; 9909 /** 9910 * Font scale factor. 9911 */ 9912 double fontScale; 9913 /** 9914 * Width of the left margin in pixels. 9915 */ 9916 int leftMargin; 9917 /** 9918 * Width of the right margin in pixels. 9919 */ 9920 int rightMargin; 9921 /** 9922 * Amount to indent the paragraph, in pixels. 9923 */ 9924 int indent; 9925 /** 9926 * Pixels of blank space above paragraphs. 9927 */ 9928 int pixelsAboveLines; 9929 /** 9930 * Pixels of blank space below paragraphs. 9931 */ 9932 int pixelsBelowLines; 9933 /** 9934 * Pixels of blank space between wrapped lines in 9935 * a paragraph. 9936 */ 9937 int pixelsInsideWrap; 9938 /** 9939 * Custom #PangoTabArray for this text. 9940 */ 9941 PangoTabArray* tabs; 9942 /** 9943 * #GtkWrapMode for text. 9944 */ 9945 GtkWrapMode wrapMode; 9946 /** 9947 * #PangoLanguage for text. 9948 */ 9949 PangoLanguage* language; 9950 GdkColor* pgBgColor; 9951 import std.bitmanip: bitfields; 9952 mixin(bitfields!( 9953 uint, "invisible", 1, 9954 uint, "bgFullHeight", 1, 9955 uint, "editable", 1, 9956 uint, "noFallback", 1, 9957 uint, "", 28 9958 )); 9959 GdkRGBA* pgBgRgba; 9960 /** 9961 * Extra space to insert between graphemes, in Pango units 9962 */ 9963 int letterSpacing; 9964 union 9965 { 9966 char* fontFeatures; 9967 uint[2] padding; 9968 } 9969 } 9970 9971 struct GtkTextBTree; 9972 9973 struct GtkTextBuffer 9974 { 9975 GObject parentInstance; 9976 GtkTextBufferPrivate* priv; 9977 } 9978 9979 struct GtkTextBufferClass 9980 { 9981 /** 9982 * The object class structure needs to be the first. 9983 */ 9984 GObjectClass parentClass; 9985 /** */ 9986 extern(C) void function(GtkTextBuffer* buffer, GtkTextIter* pos, const(char)* newText, int newTextLength) insertText; 9987 /** */ 9988 extern(C) void function(GtkTextBuffer* buffer, GtkTextIter* iter, GdkPixbuf* pixbuf) insertPixbuf; 9989 /** */ 9990 extern(C) void function(GtkTextBuffer* buffer, GtkTextIter* iter, GtkTextChildAnchor* anchor) insertChildAnchor; 9991 /** */ 9992 extern(C) void function(GtkTextBuffer* buffer, GtkTextIter* start, GtkTextIter* end) deleteRange; 9993 /** */ 9994 extern(C) void function(GtkTextBuffer* buffer) changed; 9995 /** */ 9996 extern(C) void function(GtkTextBuffer* buffer) modifiedChanged; 9997 /** */ 9998 extern(C) void function(GtkTextBuffer* buffer, GtkTextIter* location, GtkTextMark* mark) markSet; 9999 /** */ 10000 extern(C) void function(GtkTextBuffer* buffer, GtkTextMark* mark) markDeleted; 10001 /** */ 10002 extern(C) void function(GtkTextBuffer* buffer, GtkTextTag* tag, GtkTextIter* start, GtkTextIter* end) applyTag; 10003 /** */ 10004 extern(C) void function(GtkTextBuffer* buffer, GtkTextTag* tag, GtkTextIter* start, GtkTextIter* end) removeTag; 10005 /** */ 10006 extern(C) void function(GtkTextBuffer* buffer) beginUserAction; 10007 /** */ 10008 extern(C) void function(GtkTextBuffer* buffer) endUserAction; 10009 /** */ 10010 extern(C) void function(GtkTextBuffer* buffer, GtkClipboard* clipboard) pasteDone; 10011 /** */ 10012 extern(C) void function() GtkReserved1; 10013 /** */ 10014 extern(C) void function() GtkReserved2; 10015 /** */ 10016 extern(C) void function() GtkReserved3; 10017 /** */ 10018 extern(C) void function() GtkReserved4; 10019 } 10020 10021 struct GtkTextBufferPrivate; 10022 10023 struct GtkTextCellAccessible 10024 { 10025 GtkRendererCellAccessible parent; 10026 GtkTextCellAccessiblePrivate* priv; 10027 } 10028 10029 struct GtkTextCellAccessibleClass 10030 { 10031 GtkRendererCellAccessibleClass parentClass; 10032 } 10033 10034 struct GtkTextCellAccessiblePrivate; 10035 10036 struct GtkTextChildAnchor 10037 { 10038 GObject parentInstance; 10039 void* segment; 10040 } 10041 10042 struct GtkTextChildAnchorClass 10043 { 10044 GObjectClass parentClass; 10045 /** */ 10046 extern(C) void function() GtkReserved1; 10047 /** */ 10048 extern(C) void function() GtkReserved2; 10049 /** */ 10050 extern(C) void function() GtkReserved3; 10051 /** */ 10052 extern(C) void function() GtkReserved4; 10053 } 10054 10055 struct GtkTextIter 10056 { 10057 void* dummy1; 10058 void* dummy2; 10059 int dummy3; 10060 int dummy4; 10061 int dummy5; 10062 int dummy6; 10063 int dummy7; 10064 int dummy8; 10065 void* dummy9; 10066 void* dummy10; 10067 int dummy11; 10068 int dummy12; 10069 int dummy13; 10070 void* dummy14; 10071 } 10072 10073 struct GtkTextMark 10074 { 10075 GObject parentInstance; 10076 void* segment; 10077 } 10078 10079 struct GtkTextMarkClass 10080 { 10081 GObjectClass parentClass; 10082 /** */ 10083 extern(C) void function() GtkReserved1; 10084 /** */ 10085 extern(C) void function() GtkReserved2; 10086 /** */ 10087 extern(C) void function() GtkReserved3; 10088 /** */ 10089 extern(C) void function() GtkReserved4; 10090 } 10091 10092 struct GtkTextTag 10093 { 10094 GObject parentInstance; 10095 GtkTextTagPrivate* priv; 10096 } 10097 10098 struct GtkTextTagClass 10099 { 10100 GObjectClass parentClass; 10101 /** 10102 * 10103 * Params: 10104 * tag = a #GtkTextTag 10105 * eventObject = object that received the event, such as a widget 10106 * event = the event 10107 * iter = location where the event was received 10108 * Returns: result of signal emission (whether the event was handled) 10109 */ 10110 extern(C) int function(GtkTextTag* tag, GObject* eventObject, GdkEvent* event, GtkTextIter* iter) event; 10111 /** */ 10112 extern(C) void function() GtkReserved1; 10113 /** */ 10114 extern(C) void function() GtkReserved2; 10115 /** */ 10116 extern(C) void function() GtkReserved3; 10117 /** */ 10118 extern(C) void function() GtkReserved4; 10119 } 10120 10121 struct GtkTextTagPrivate; 10122 10123 struct GtkTextTagTable 10124 { 10125 GObject parentInstance; 10126 GtkTextTagTablePrivate* priv; 10127 } 10128 10129 struct GtkTextTagTableClass 10130 { 10131 GObjectClass parentClass; 10132 /** */ 10133 extern(C) void function(GtkTextTagTable* table, GtkTextTag* tag, int sizeChanged) tagChanged; 10134 /** */ 10135 extern(C) void function(GtkTextTagTable* table, GtkTextTag* tag) tagAdded; 10136 /** */ 10137 extern(C) void function(GtkTextTagTable* table, GtkTextTag* tag) tagRemoved; 10138 /** */ 10139 extern(C) void function() GtkReserved1; 10140 /** */ 10141 extern(C) void function() GtkReserved2; 10142 /** */ 10143 extern(C) void function() GtkReserved3; 10144 /** */ 10145 extern(C) void function() GtkReserved4; 10146 } 10147 10148 struct GtkTextTagTablePrivate; 10149 10150 struct GtkTextView 10151 { 10152 GtkContainer parentInstance; 10153 GtkTextViewPrivate* priv; 10154 } 10155 10156 struct GtkTextViewAccessible 10157 { 10158 GtkContainerAccessible parent; 10159 GtkTextViewAccessiblePrivate* priv; 10160 } 10161 10162 struct GtkTextViewAccessibleClass 10163 { 10164 GtkContainerAccessibleClass parentClass; 10165 } 10166 10167 struct GtkTextViewAccessiblePrivate; 10168 10169 struct GtkTextViewClass 10170 { 10171 /** 10172 * The object class structure needs to be the first 10173 */ 10174 GtkContainerClass parentClass; 10175 /** */ 10176 extern(C) void function(GtkTextView* textView, GtkWidget* popup) populatePopup; 10177 /** */ 10178 extern(C) void function(GtkTextView* textView, GtkMovementStep step, int count, int extendSelection) moveCursor; 10179 /** */ 10180 extern(C) void function(GtkTextView* textView) setAnchor; 10181 /** */ 10182 extern(C) void function(GtkTextView* textView, const(char)* str) insertAtCursor; 10183 /** */ 10184 extern(C) void function(GtkTextView* textView, GtkDeleteType type, int count) deleteFromCursor; 10185 /** */ 10186 extern(C) void function(GtkTextView* textView) backspace; 10187 /** */ 10188 extern(C) void function(GtkTextView* textView) cutClipboard; 10189 /** */ 10190 extern(C) void function(GtkTextView* textView) copyClipboard; 10191 /** */ 10192 extern(C) void function(GtkTextView* textView) pasteClipboard; 10193 /** */ 10194 extern(C) void function(GtkTextView* textView) toggleOverwrite; 10195 /** */ 10196 extern(C) GtkTextBuffer* function(GtkTextView* textView) createBuffer; 10197 /** */ 10198 extern(C) void function(GtkTextView* textView, GtkTextViewLayer layer, cairo_t* cr) drawLayer; 10199 /** */ 10200 extern(C) int function(GtkTextView* textView, GtkTextExtendSelection granularity, GtkTextIter* location, GtkTextIter* start, GtkTextIter* end) extendSelection; 10201 /** */ 10202 extern(C) void function() GtkReserved1; 10203 /** */ 10204 extern(C) void function() GtkReserved2; 10205 /** */ 10206 extern(C) void function() GtkReserved3; 10207 /** */ 10208 extern(C) void function() GtkReserved4; 10209 /** */ 10210 extern(C) void function() GtkReserved5; 10211 } 10212 10213 struct GtkTextViewPrivate; 10214 10215 struct GtkThemeEngine; 10216 10217 struct GtkThemingEngine 10218 { 10219 GObject parentObject; 10220 GtkThemingEnginePrivate* priv; 10221 } 10222 10223 /** 10224 * Base class for theming engines. 10225 */ 10226 struct GtkThemingEngineClass 10227 { 10228 /** 10229 * The parent class. 10230 */ 10231 GObjectClass parentClass; 10232 /** */ 10233 extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double x0, double y0, double x1, double y1) renderLine; 10234 /** */ 10235 extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double x, double y, double width, double height) renderBackground; 10236 /** */ 10237 extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double x, double y, double width, double height) renderFrame; 10238 /** */ 10239 extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double x, double y, double width, double height, GtkPositionType gapSide, double xy0Gap, double xy1Gap) renderFrameGap; 10240 /** */ 10241 extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double x, double y, double width, double height, GtkPositionType gapSide) renderExtension; 10242 /** */ 10243 extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double x, double y, double width, double height) renderCheck; 10244 /** */ 10245 extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double x, double y, double width, double height) renderOption; 10246 /** */ 10247 extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double angle, double x, double y, double size) renderArrow; 10248 /** */ 10249 extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double x, double y, double width, double height) renderExpander; 10250 /** */ 10251 extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double x, double y, double width, double height) renderFocus; 10252 /** */ 10253 extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double x, double y, PangoLayout* layout) renderLayout; 10254 /** */ 10255 extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double x, double y, double width, double height, GtkOrientation orientation) renderSlider; 10256 /** */ 10257 extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double x, double y, double width, double height) renderHandle; 10258 /** */ 10259 extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double x, double y, double width, double height) renderActivity; 10260 /** */ 10261 extern(C) GdkPixbuf* function(GtkThemingEngine* engine, GtkIconSource* source, GtkIconSize size) renderIconPixbuf; 10262 /** */ 10263 extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, GdkPixbuf* pixbuf, double x, double y) renderIcon; 10264 /** */ 10265 extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, cairo_surface_t* surface, double x, double y) renderIconSurface; 10266 void*[14] padding; 10267 } 10268 10269 struct GtkThemingEnginePrivate; 10270 10271 struct GtkToggleAction 10272 { 10273 GtkAction parent; 10274 GtkToggleActionPrivate* privateData; 10275 } 10276 10277 struct GtkToggleActionClass 10278 { 10279 GtkActionClass parentClass; 10280 /** */ 10281 extern(C) void function(GtkToggleAction* action) toggled; 10282 /** */ 10283 extern(C) void function() GtkReserved1; 10284 /** */ 10285 extern(C) void function() GtkReserved2; 10286 /** */ 10287 extern(C) void function() GtkReserved3; 10288 /** */ 10289 extern(C) void function() GtkReserved4; 10290 } 10291 10292 /** 10293 * #GtkToggleActionEntry structs are used with 10294 * gtk_action_group_add_toggle_actions() to construct toggle actions. 10295 */ 10296 struct GtkToggleActionEntry 10297 { 10298 /** 10299 * The name of the action. 10300 */ 10301 const(char)* name; 10302 /** 10303 * The stock id for the action, or the name of an icon from the 10304 * icon theme. 10305 */ 10306 const(char)* stockId; 10307 /** 10308 * The label for the action. This field should typically be marked 10309 * for translation, see gtk_action_group_set_translation_domain(). 10310 */ 10311 const(char)* label; 10312 /** 10313 * The accelerator for the action, in the format understood by 10314 * gtk_accelerator_parse(). 10315 */ 10316 const(char)* accelerator; 10317 /** 10318 * The tooltip for the action. This field should typically be 10319 * marked for translation, see gtk_action_group_set_translation_domain(). 10320 */ 10321 const(char)* tooltip; 10322 /** 10323 * The function to call when the action is activated. 10324 */ 10325 GCallback callback; 10326 /** 10327 * The initial state of the toggle action. 10328 */ 10329 bool isActive; 10330 } 10331 10332 struct GtkToggleActionPrivate; 10333 10334 struct GtkToggleButton 10335 { 10336 GtkButton button; 10337 GtkToggleButtonPrivate* priv; 10338 } 10339 10340 struct GtkToggleButtonAccessible 10341 { 10342 GtkButtonAccessible parent; 10343 GtkToggleButtonAccessiblePrivate* priv; 10344 } 10345 10346 struct GtkToggleButtonAccessibleClass 10347 { 10348 GtkButtonAccessibleClass parentClass; 10349 } 10350 10351 struct GtkToggleButtonAccessiblePrivate; 10352 10353 struct GtkToggleButtonClass 10354 { 10355 GtkButtonClass parentClass; 10356 /** */ 10357 extern(C) void function(GtkToggleButton* toggleButton) toggled; 10358 /** */ 10359 extern(C) void function() GtkReserved1; 10360 /** */ 10361 extern(C) void function() GtkReserved2; 10362 /** */ 10363 extern(C) void function() GtkReserved3; 10364 /** */ 10365 extern(C) void function() GtkReserved4; 10366 } 10367 10368 struct GtkToggleButtonPrivate; 10369 10370 struct GtkToggleToolButton 10371 { 10372 GtkToolButton parent; 10373 GtkToggleToolButtonPrivate* priv; 10374 } 10375 10376 struct GtkToggleToolButtonClass 10377 { 10378 /** 10379 * The parent class. 10380 */ 10381 GtkToolButtonClass parentClass; 10382 /** */ 10383 extern(C) void function(GtkToggleToolButton* button) toggled; 10384 /** */ 10385 extern(C) void function() GtkReserved1; 10386 /** */ 10387 extern(C) void function() GtkReserved2; 10388 /** */ 10389 extern(C) void function() GtkReserved3; 10390 /** */ 10391 extern(C) void function() GtkReserved4; 10392 } 10393 10394 struct GtkToggleToolButtonPrivate; 10395 10396 struct GtkToolButton 10397 { 10398 GtkToolItem parent; 10399 GtkToolButtonPrivate* priv; 10400 } 10401 10402 struct GtkToolButtonClass 10403 { 10404 /** 10405 * The parent class. 10406 */ 10407 GtkToolItemClass parentClass; 10408 GType buttonType; 10409 /** */ 10410 extern(C) void function(GtkToolButton* toolItem) clicked; 10411 /** */ 10412 extern(C) void function() GtkReserved1; 10413 /** */ 10414 extern(C) void function() GtkReserved2; 10415 /** */ 10416 extern(C) void function() GtkReserved3; 10417 /** */ 10418 extern(C) void function() GtkReserved4; 10419 } 10420 10421 struct GtkToolButtonPrivate; 10422 10423 struct GtkToolItem 10424 { 10425 GtkBin parent; 10426 GtkToolItemPrivate* priv; 10427 } 10428 10429 struct GtkToolItemClass 10430 { 10431 /** 10432 * The parent class. 10433 */ 10434 GtkBinClass parentClass; 10435 /** */ 10436 extern(C) int function(GtkToolItem* toolItem) createMenuProxy; 10437 /** */ 10438 extern(C) void function(GtkToolItem* toolItem) toolbarReconfigured; 10439 /** */ 10440 extern(C) void function() GtkReserved1; 10441 /** */ 10442 extern(C) void function() GtkReserved2; 10443 /** */ 10444 extern(C) void function() GtkReserved3; 10445 /** */ 10446 extern(C) void function() GtkReserved4; 10447 } 10448 10449 struct GtkToolItemGroup 10450 { 10451 GtkContainer parentInstance; 10452 GtkToolItemGroupPrivate* priv; 10453 } 10454 10455 struct GtkToolItemGroupClass 10456 { 10457 /** 10458 * The parent class. 10459 */ 10460 GtkContainerClass parentClass; 10461 /** */ 10462 extern(C) void function() GtkReserved1; 10463 /** */ 10464 extern(C) void function() GtkReserved2; 10465 /** */ 10466 extern(C) void function() GtkReserved3; 10467 /** */ 10468 extern(C) void function() GtkReserved4; 10469 } 10470 10471 struct GtkToolItemGroupPrivate; 10472 10473 struct GtkToolItemPrivate; 10474 10475 struct GtkToolPalette 10476 { 10477 GtkContainer parentInstance; 10478 GtkToolPalettePrivate* priv; 10479 } 10480 10481 struct GtkToolPaletteClass 10482 { 10483 /** 10484 * The parent class. 10485 */ 10486 GtkContainerClass parentClass; 10487 /** */ 10488 extern(C) void function() GtkReserved1; 10489 /** */ 10490 extern(C) void function() GtkReserved2; 10491 /** */ 10492 extern(C) void function() GtkReserved3; 10493 /** */ 10494 extern(C) void function() GtkReserved4; 10495 } 10496 10497 struct GtkToolPalettePrivate; 10498 10499 struct GtkToolShell; 10500 10501 /** 10502 * Virtual function table for the #GtkToolShell interface. 10503 */ 10504 struct GtkToolShellIface 10505 { 10506 GTypeInterface gIface; 10507 /** */ 10508 extern(C) GtkIconSize function(GtkToolShell* shell) getIconSize; 10509 /** 10510 * 10511 * Params: 10512 * shell = a #GtkToolShell 10513 * Returns: the current orientation of @shell 10514 */ 10515 extern(C) GtkOrientation function(GtkToolShell* shell) getOrientation; 10516 /** 10517 * 10518 * Params: 10519 * shell = a #GtkToolShell 10520 * Returns: the current style of @shell 10521 */ 10522 extern(C) GtkToolbarStyle function(GtkToolShell* shell) getStyle; 10523 /** 10524 * 10525 * Params: 10526 * shell = a #GtkToolShell 10527 * Returns: The relief style of buttons on @shell. 10528 */ 10529 extern(C) GtkReliefStyle function(GtkToolShell* shell) getReliefStyle; 10530 /** */ 10531 extern(C) void function(GtkToolShell* shell) rebuildMenu; 10532 /** 10533 * 10534 * Params: 10535 * shell = a #GtkToolShell 10536 * Returns: the current text orientation of @shell 10537 */ 10538 extern(C) GtkOrientation function(GtkToolShell* shell) getTextOrientation; 10539 /** 10540 * 10541 * Params: 10542 * shell = a #GtkToolShell 10543 * Returns: the current text alignment of @shell 10544 */ 10545 extern(C) float function(GtkToolShell* shell) getTextAlignment; 10546 /** 10547 * 10548 * Params: 10549 * shell = a #GtkToolShell 10550 * Returns: the current ellipsize mode of @shell 10551 */ 10552 extern(C) PangoEllipsizeMode function(GtkToolShell* shell) getEllipsizeMode; 10553 /** 10554 * 10555 * Params: 10556 * shell = a #GtkToolShell 10557 * Returns: the current text size group of @shell 10558 */ 10559 extern(C) GtkSizeGroup* function(GtkToolShell* shell) getTextSizeGroup; 10560 } 10561 10562 struct GtkToolbar 10563 { 10564 GtkContainer container; 10565 GtkToolbarPrivate* priv; 10566 } 10567 10568 struct GtkToolbarClass 10569 { 10570 GtkContainerClass parentClass; 10571 /** */ 10572 extern(C) void function(GtkToolbar* toolbar, GtkOrientation orientation) orientationChanged; 10573 /** */ 10574 extern(C) void function(GtkToolbar* toolbar, GtkToolbarStyle style) styleChanged; 10575 /** */ 10576 extern(C) int function(GtkToolbar* toolbar, int x, int y, int buttonNumber) popupContextMenu; 10577 /** */ 10578 extern(C) void function() GtkReserved1; 10579 /** */ 10580 extern(C) void function() GtkReserved2; 10581 /** */ 10582 extern(C) void function() GtkReserved3; 10583 /** */ 10584 extern(C) void function() GtkReserved4; 10585 } 10586 10587 struct GtkToolbarPrivate; 10588 10589 struct GtkTooltip; 10590 10591 struct GtkToplevelAccessible 10592 { 10593 AtkObject parent; 10594 GtkToplevelAccessiblePrivate* priv; 10595 } 10596 10597 struct GtkToplevelAccessibleClass 10598 { 10599 AtkObjectClass parentClass; 10600 } 10601 10602 struct GtkToplevelAccessiblePrivate; 10603 10604 struct GtkTreeDragDest; 10605 10606 struct GtkTreeDragDestIface 10607 { 10608 GTypeInterface gIface; 10609 /** 10610 * 10611 * Params: 10612 * dragDest = a #GtkTreeDragDest 10613 * dest = row to drop in front of 10614 * selectionData = data to drop 10615 * Returns: whether a new row was created before position @dest 10616 */ 10617 extern(C) int function(GtkTreeDragDest* dragDest, GtkTreePath* dest, GtkSelectionData* selectionData) dragDataReceived; 10618 /** 10619 * 10620 * Params: 10621 * dragDest = a #GtkTreeDragDest 10622 * destPath = destination row 10623 * selectionData = the data being dragged 10624 * Returns: %TRUE if a drop is possible before @dest_path 10625 */ 10626 extern(C) int function(GtkTreeDragDest* dragDest, GtkTreePath* destPath, GtkSelectionData* selectionData) rowDropPossible; 10627 } 10628 10629 struct GtkTreeDragSource; 10630 10631 struct GtkTreeDragSourceIface 10632 { 10633 GTypeInterface gIface; 10634 /** 10635 * 10636 * Params: 10637 * dragSource = a #GtkTreeDragSource 10638 * path = row on which user is initiating a drag 10639 * Returns: %TRUE if the row can be dragged 10640 */ 10641 extern(C) int function(GtkTreeDragSource* dragSource, GtkTreePath* path) rowDraggable; 10642 /** 10643 * 10644 * Params: 10645 * dragSource = a #GtkTreeDragSource 10646 * path = row that was dragged 10647 * selectionData = a #GtkSelectionData to fill with data 10648 * from the dragged row 10649 * Returns: %TRUE if data of the required type was provided 10650 */ 10651 extern(C) int function(GtkTreeDragSource* dragSource, GtkTreePath* path, GtkSelectionData* selectionData) dragDataGet; 10652 /** 10653 * 10654 * Params: 10655 * dragSource = a #GtkTreeDragSource 10656 * path = row that was being dragged 10657 * Returns: %TRUE if the row was successfully deleted 10658 */ 10659 extern(C) int function(GtkTreeDragSource* dragSource, GtkTreePath* path) dragDataDelete; 10660 } 10661 10662 struct GtkTreeIter 10663 { 10664 /** 10665 * a unique stamp to catch invalid iterators 10666 */ 10667 int stamp; 10668 /** 10669 * model-specific data 10670 */ 10671 void* userData; 10672 /** 10673 * model-specific data 10674 */ 10675 void* userData2; 10676 /** 10677 * model-specific data 10678 */ 10679 void* userData3; 10680 } 10681 10682 struct GtkTreeModel; 10683 10684 struct GtkTreeModelFilter 10685 { 10686 GObject parent; 10687 GtkTreeModelFilterPrivate* priv; 10688 } 10689 10690 struct GtkTreeModelFilterClass 10691 { 10692 GObjectClass parentClass; 10693 /** */ 10694 extern(C) int function(GtkTreeModelFilter* self, GtkTreeModel* childModel, GtkTreeIter* iter) visible; 10695 /** */ 10696 extern(C) void function(GtkTreeModelFilter* self, GtkTreeModel* childModel, GtkTreeIter* iter, GValue* value, int column) modify; 10697 /** */ 10698 extern(C) void function() GtkReserved1; 10699 /** */ 10700 extern(C) void function() GtkReserved2; 10701 /** */ 10702 extern(C) void function() GtkReserved3; 10703 /** */ 10704 extern(C) void function() GtkReserved4; 10705 } 10706 10707 struct GtkTreeModelFilterPrivate; 10708 10709 struct GtkTreeModelIface 10710 { 10711 GTypeInterface gIface; 10712 /** */ 10713 extern(C) void function(GtkTreeModel* treeModel, GtkTreePath* path, GtkTreeIter* iter) rowChanged; 10714 /** */ 10715 extern(C) void function(GtkTreeModel* treeModel, GtkTreePath* path, GtkTreeIter* iter) rowInserted; 10716 /** */ 10717 extern(C) void function(GtkTreeModel* treeModel, GtkTreePath* path, GtkTreeIter* iter) rowHasChildToggled; 10718 /** */ 10719 extern(C) void function(GtkTreeModel* treeModel, GtkTreePath* path) rowDeleted; 10720 /** */ 10721 extern(C) void function(GtkTreeModel* treeModel, GtkTreePath* path, GtkTreeIter* iter, int* newOrder) rowsReordered; 10722 /** 10723 * 10724 * Params: 10725 * treeModel = a #GtkTreeModel 10726 * Returns: the flags supported by this interface 10727 */ 10728 extern(C) GtkTreeModelFlags function(GtkTreeModel* treeModel) getFlags; 10729 /** 10730 * 10731 * Params: 10732 * treeModel = a #GtkTreeModel 10733 * Returns: the number of columns 10734 */ 10735 extern(C) int function(GtkTreeModel* treeModel) getNColumns; 10736 /** 10737 * 10738 * Params: 10739 * treeModel = a #GtkTreeModel 10740 * index = the column index 10741 * Returns: the type of the column 10742 */ 10743 extern(C) GType function(GtkTreeModel* treeModel, int index) getColumnType; 10744 /** 10745 * 10746 * Params: 10747 * treeModel = a #GtkTreeModel 10748 * iter = the uninitialized #GtkTreeIter-struct 10749 * path = the #GtkTreePath-struct 10750 * Returns: %TRUE, if @iter was set 10751 */ 10752 extern(C) int function(GtkTreeModel* treeModel, GtkTreeIter* iter, GtkTreePath* path) getIter; 10753 /** 10754 * 10755 * Params: 10756 * treeModel = a #GtkTreeModel 10757 * iter = the #GtkTreeIter-struct 10758 * Returns: a newly-created #GtkTreePath-struct 10759 */ 10760 extern(C) GtkTreePath* function(GtkTreeModel* treeModel, GtkTreeIter* iter) getPath; 10761 /** */ 10762 extern(C) void function(GtkTreeModel* treeModel, GtkTreeIter* iter, int column, GValue* value) getValue; 10763 /** 10764 * 10765 * Params: 10766 * treeModel = a #GtkTreeModel 10767 * iter = the #GtkTreeIter-struct 10768 * Returns: %TRUE if @iter has been changed to the next node 10769 */ 10770 extern(C) int function(GtkTreeModel* treeModel, GtkTreeIter* iter) iterNext; 10771 /** 10772 * 10773 * Params: 10774 * treeModel = a #GtkTreeModel 10775 * iter = the #GtkTreeIter-struct 10776 * Returns: %TRUE if @iter has been changed to the previous node 10777 */ 10778 extern(C) int function(GtkTreeModel* treeModel, GtkTreeIter* iter) iterPrevious; 10779 /** 10780 * 10781 * Params: 10782 * treeModel = a #GtkTreeModel 10783 * iter = the new #GtkTreeIter-struct to be set to the child 10784 * parent = the #GtkTreeIter-struct, or %NULL 10785 * Returns: %TRUE, if @iter has been set to the first child 10786 */ 10787 extern(C) int function(GtkTreeModel* treeModel, GtkTreeIter* iter, GtkTreeIter* parent) iterChildren; 10788 /** 10789 * 10790 * Params: 10791 * treeModel = a #GtkTreeModel 10792 * iter = the #GtkTreeIter-struct to test for children 10793 * Returns: %TRUE if @iter has children 10794 */ 10795 extern(C) int function(GtkTreeModel* treeModel, GtkTreeIter* iter) iterHasChild; 10796 /** 10797 * 10798 * Params: 10799 * treeModel = a #GtkTreeModel 10800 * iter = the #GtkTreeIter-struct, or %NULL 10801 * Returns: the number of children of @iter 10802 */ 10803 extern(C) int function(GtkTreeModel* treeModel, GtkTreeIter* iter) iterNChildren; 10804 /** 10805 * 10806 * Params: 10807 * treeModel = a #GtkTreeModel 10808 * iter = the #GtkTreeIter-struct to set to the nth child 10809 * parent = the #GtkTreeIter-struct to get the child from, or %NULL. 10810 * n = the index of the desired child 10811 * Returns: %TRUE, if @parent has an @n-th child 10812 */ 10813 extern(C) int function(GtkTreeModel* treeModel, GtkTreeIter* iter, GtkTreeIter* parent, int n) iterNthChild; 10814 /** 10815 * 10816 * Params: 10817 * treeModel = a #GtkTreeModel 10818 * iter = the new #GtkTreeIter-struct to set to the parent 10819 * child = the #GtkTreeIter-struct 10820 * Returns: %TRUE, if @iter is set to the parent of @child 10821 */ 10822 extern(C) int function(GtkTreeModel* treeModel, GtkTreeIter* iter, GtkTreeIter* child) iterParent; 10823 /** */ 10824 extern(C) void function(GtkTreeModel* treeModel, GtkTreeIter* iter) refNode; 10825 /** */ 10826 extern(C) void function(GtkTreeModel* treeModel, GtkTreeIter* iter) unrefNode; 10827 } 10828 10829 struct GtkTreeModelSort 10830 { 10831 GObject parent; 10832 GtkTreeModelSortPrivate* priv; 10833 } 10834 10835 struct GtkTreeModelSortClass 10836 { 10837 GObjectClass parentClass; 10838 /** */ 10839 extern(C) void function() GtkReserved1; 10840 /** */ 10841 extern(C) void function() GtkReserved2; 10842 /** */ 10843 extern(C) void function() GtkReserved3; 10844 /** */ 10845 extern(C) void function() GtkReserved4; 10846 } 10847 10848 struct GtkTreeModelSortPrivate; 10849 10850 struct GtkTreePath; 10851 10852 struct GtkTreeRowReference; 10853 10854 struct GtkTreeSelection 10855 { 10856 GObject parent; 10857 GtkTreeSelectionPrivate* priv; 10858 } 10859 10860 struct GtkTreeSelectionClass 10861 { 10862 /** 10863 * The parent class. 10864 */ 10865 GObjectClass parentClass; 10866 /** */ 10867 extern(C) void function(GtkTreeSelection* selection) changed; 10868 /** */ 10869 extern(C) void function() GtkReserved1; 10870 /** */ 10871 extern(C) void function() GtkReserved2; 10872 /** */ 10873 extern(C) void function() GtkReserved3; 10874 /** */ 10875 extern(C) void function() GtkReserved4; 10876 } 10877 10878 struct GtkTreeSelectionPrivate; 10879 10880 struct GtkTreeSortable; 10881 10882 struct GtkTreeSortableIface 10883 { 10884 GTypeInterface gIface; 10885 /** */ 10886 extern(C) void function(GtkTreeSortable* sortable) sortColumnChanged; 10887 /** 10888 * 10889 * Params: 10890 * sortable = A #GtkTreeSortable 10891 * sortColumnId = The sort column id to be filled in 10892 * order = The #GtkSortType to be filled in 10893 * Returns: %TRUE if the sort column is not one of the special sort 10894 * column ids. 10895 */ 10896 extern(C) int function(GtkTreeSortable* sortable, int* sortColumnId, GtkSortType* order) getSortColumnId; 10897 /** */ 10898 extern(C) void function(GtkTreeSortable* sortable, int sortColumnId, GtkSortType order) setSortColumnId; 10899 /** */ 10900 extern(C) void function(GtkTreeSortable* sortable, int sortColumnId, GtkTreeIterCompareFunc sortFunc, void* userData, GDestroyNotify destroy) setSortFunc; 10901 /** */ 10902 extern(C) void function(GtkTreeSortable* sortable, GtkTreeIterCompareFunc sortFunc, void* userData, GDestroyNotify destroy) setDefaultSortFunc; 10903 /** 10904 * 10905 * Params: 10906 * sortable = A #GtkTreeSortable 10907 * Returns: %TRUE, if the model has a default sort function 10908 */ 10909 extern(C) int function(GtkTreeSortable* sortable) hasDefaultSortFunc; 10910 } 10911 10912 struct GtkTreeStore 10913 { 10914 GObject parent; 10915 GtkTreeStorePrivate* priv; 10916 } 10917 10918 struct GtkTreeStoreClass 10919 { 10920 GObjectClass parentClass; 10921 /** */ 10922 extern(C) void function() GtkReserved1; 10923 /** */ 10924 extern(C) void function() GtkReserved2; 10925 /** */ 10926 extern(C) void function() GtkReserved3; 10927 /** */ 10928 extern(C) void function() GtkReserved4; 10929 } 10930 10931 struct GtkTreeStorePrivate; 10932 10933 struct GtkTreeView 10934 { 10935 GtkContainer parent; 10936 GtkTreeViewPrivate* priv; 10937 } 10938 10939 struct GtkTreeViewAccessible 10940 { 10941 GtkContainerAccessible parent; 10942 GtkTreeViewAccessiblePrivate* priv; 10943 } 10944 10945 struct GtkTreeViewAccessibleClass 10946 { 10947 GtkContainerAccessibleClass parentClass; 10948 } 10949 10950 struct GtkTreeViewAccessiblePrivate; 10951 10952 struct GtkTreeViewClass 10953 { 10954 GtkContainerClass parentClass; 10955 /** */ 10956 extern(C) void function(GtkTreeView* treeView, GtkTreePath* path, GtkTreeViewColumn* column) rowActivated; 10957 /** */ 10958 extern(C) int function(GtkTreeView* treeView, GtkTreeIter* iter, GtkTreePath* path) testExpandRow; 10959 /** */ 10960 extern(C) int function(GtkTreeView* treeView, GtkTreeIter* iter, GtkTreePath* path) testCollapseRow; 10961 /** */ 10962 extern(C) void function(GtkTreeView* treeView, GtkTreeIter* iter, GtkTreePath* path) rowExpanded; 10963 /** */ 10964 extern(C) void function(GtkTreeView* treeView, GtkTreeIter* iter, GtkTreePath* path) rowCollapsed; 10965 /** */ 10966 extern(C) void function(GtkTreeView* treeView) columnsChanged; 10967 /** */ 10968 extern(C) void function(GtkTreeView* treeView) cursorChanged; 10969 /** */ 10970 extern(C) int function(GtkTreeView* treeView, GtkMovementStep step, int count) moveCursor; 10971 /** */ 10972 extern(C) int function(GtkTreeView* treeView) selectAll; 10973 /** */ 10974 extern(C) int function(GtkTreeView* treeView) unselectAll; 10975 /** */ 10976 extern(C) int function(GtkTreeView* treeView, int startEditing) selectCursorRow; 10977 /** */ 10978 extern(C) int function(GtkTreeView* treeView) toggleCursorRow; 10979 /** */ 10980 extern(C) int function(GtkTreeView* treeView, int logical, int expand, int openAll) expandCollapseCursorRow; 10981 /** */ 10982 extern(C) int function(GtkTreeView* treeView) selectCursorParent; 10983 /** */ 10984 extern(C) int function(GtkTreeView* treeView) startInteractiveSearch; 10985 /** */ 10986 extern(C) void function() GtkReserved1; 10987 /** */ 10988 extern(C) void function() GtkReserved2; 10989 /** */ 10990 extern(C) void function() GtkReserved3; 10991 /** */ 10992 extern(C) void function() GtkReserved4; 10993 /** */ 10994 extern(C) void function() GtkReserved5; 10995 /** */ 10996 extern(C) void function() GtkReserved6; 10997 /** */ 10998 extern(C) void function() GtkReserved7; 10999 /** */ 11000 extern(C) void function() GtkReserved8; 11001 } 11002 11003 struct GtkTreeViewColumn 11004 { 11005 GObject parentInstance; 11006 GtkTreeViewColumnPrivate* priv; 11007 } 11008 11009 struct GtkTreeViewColumnClass 11010 { 11011 GObjectClass parentClass; 11012 /** */ 11013 extern(C) void function(GtkTreeViewColumn* treeColumn) clicked; 11014 /** */ 11015 extern(C) void function() GtkReserved1; 11016 /** */ 11017 extern(C) void function() GtkReserved2; 11018 /** */ 11019 extern(C) void function() GtkReserved3; 11020 /** */ 11021 extern(C) void function() GtkReserved4; 11022 } 11023 11024 struct GtkTreeViewColumnPrivate; 11025 11026 struct GtkTreeViewPrivate; 11027 11028 struct GtkUIManager 11029 { 11030 GObject parent; 11031 GtkUIManagerPrivate* privateData; 11032 } 11033 11034 struct GtkUIManagerClass 11035 { 11036 GObjectClass parentClass; 11037 /** */ 11038 extern(C) void function(GtkUIManager* manager, GtkWidget* widget) addWidget; 11039 /** */ 11040 extern(C) void function(GtkUIManager* manager) actionsChanged; 11041 /** */ 11042 extern(C) void function(GtkUIManager* manager, GtkAction* action, GtkWidget* proxy) connectProxy; 11043 /** */ 11044 extern(C) void function(GtkUIManager* manager, GtkAction* action, GtkWidget* proxy) disconnectProxy; 11045 /** */ 11046 extern(C) void function(GtkUIManager* manager, GtkAction* action) preActivate; 11047 /** */ 11048 extern(C) void function(GtkUIManager* manager, GtkAction* action) postActivate; 11049 /** 11050 * 11051 * Params: 11052 * manager = a #GtkUIManager 11053 * path = a path 11054 * Returns: the widget found by following the path, 11055 * or %NULL if no widget was found 11056 */ 11057 extern(C) GtkWidget* function(GtkUIManager* manager, const(char)* path) getWidget; 11058 /** 11059 * 11060 * Params: 11061 * manager = a #GtkUIManager 11062 * path = a path 11063 * Returns: the action whose proxy widget is found by following the path, 11064 * or %NULL if no widget was found. 11065 */ 11066 extern(C) GtkAction* function(GtkUIManager* manager, const(char)* path) getAction; 11067 /** */ 11068 extern(C) void function() GtkReserved1; 11069 /** */ 11070 extern(C) void function() GtkReserved2; 11071 /** */ 11072 extern(C) void function() GtkReserved3; 11073 /** */ 11074 extern(C) void function() GtkReserved4; 11075 } 11076 11077 struct GtkUIManagerPrivate; 11078 11079 struct GtkVBox 11080 { 11081 GtkBox box; 11082 } 11083 11084 struct GtkVBoxClass 11085 { 11086 GtkBoxClass parentClass; 11087 } 11088 11089 struct GtkVButtonBox 11090 { 11091 GtkButtonBox buttonBox; 11092 } 11093 11094 struct GtkVButtonBoxClass 11095 { 11096 GtkButtonBoxClass parentClass; 11097 } 11098 11099 struct GtkVPaned 11100 { 11101 GtkPaned paned; 11102 } 11103 11104 struct GtkVPanedClass 11105 { 11106 GtkPanedClass parentClass; 11107 } 11108 11109 struct GtkVScale 11110 { 11111 GtkScale scale; 11112 } 11113 11114 struct GtkVScaleClass 11115 { 11116 GtkScaleClass parentClass; 11117 } 11118 11119 struct GtkVScrollbar 11120 { 11121 GtkScrollbar scrollbar; 11122 } 11123 11124 struct GtkVScrollbarClass 11125 { 11126 GtkScrollbarClass parentClass; 11127 } 11128 11129 struct GtkVSeparator 11130 { 11131 GtkSeparator separator; 11132 } 11133 11134 struct GtkVSeparatorClass 11135 { 11136 GtkSeparatorClass parentClass; 11137 } 11138 11139 struct GtkViewport 11140 { 11141 GtkBin bin; 11142 GtkViewportPrivate* priv; 11143 } 11144 11145 struct GtkViewportClass 11146 { 11147 /** 11148 * The parent class. 11149 */ 11150 GtkBinClass parentClass; 11151 /** */ 11152 extern(C) void function() GtkReserved1; 11153 /** */ 11154 extern(C) void function() GtkReserved2; 11155 /** */ 11156 extern(C) void function() GtkReserved3; 11157 /** */ 11158 extern(C) void function() GtkReserved4; 11159 } 11160 11161 struct GtkViewportPrivate; 11162 11163 struct GtkVolumeButton 11164 { 11165 GtkScaleButton parent; 11166 } 11167 11168 struct GtkVolumeButtonClass 11169 { 11170 GtkScaleButtonClass parentClass; 11171 /** */ 11172 extern(C) void function() GtkReserved1; 11173 /** */ 11174 extern(C) void function() GtkReserved2; 11175 /** */ 11176 extern(C) void function() GtkReserved3; 11177 /** */ 11178 extern(C) void function() GtkReserved4; 11179 } 11180 11181 struct GtkWidget 11182 { 11183 GObject parentInstance; 11184 GtkWidgetPrivate* priv; 11185 } 11186 11187 struct GtkWidgetAccessible 11188 { 11189 GtkAccessible parent; 11190 GtkWidgetAccessiblePrivate* priv; 11191 } 11192 11193 struct GtkWidgetAccessibleClass 11194 { 11195 GtkAccessibleClass parentClass; 11196 /** */ 11197 extern(C) void function(GObject* object, GParamSpec* pspec) notifyGtk; 11198 } 11199 11200 struct GtkWidgetAccessiblePrivate; 11201 11202 struct GtkWidgetClass 11203 { 11204 /** 11205 * The object class structure needs to be the first 11206 * element in the widget class structure in order for the class mechanism 11207 * to work correctly. This allows a GtkWidgetClass pointer to be cast to 11208 * a GObjectClass pointer. 11209 */ 11210 GObjectClass parentClass; 11211 /** 11212 * The signal to emit when a widget of this class is 11213 * activated, gtk_widget_activate() handles the emission. 11214 * Implementation of this signal is optional. 11215 */ 11216 uint activateSignal; 11217 /** */ 11218 extern(C) void function(GtkWidget* widget, uint nPspecs, GParamSpec** pspecs) dispatchChildPropertiesChanged; 11219 /** */ 11220 extern(C) void function(GtkWidget* widget) destroy; 11221 /** */ 11222 extern(C) void function(GtkWidget* widget) show; 11223 /** */ 11224 extern(C) void function(GtkWidget* widget) showAll; 11225 /** */ 11226 extern(C) void function(GtkWidget* widget) hide; 11227 /** */ 11228 extern(C) void function(GtkWidget* widget) map; 11229 /** */ 11230 extern(C) void function(GtkWidget* widget) unmap; 11231 /** */ 11232 extern(C) void function(GtkWidget* widget) realize; 11233 /** */ 11234 extern(C) void function(GtkWidget* widget) unrealize; 11235 /** */ 11236 extern(C) void function(GtkWidget* widget, GtkAllocation* allocation) sizeAllocate; 11237 /** */ 11238 extern(C) void function(GtkWidget* widget, GtkStateType previousState) stateChanged; 11239 /** */ 11240 extern(C) void function(GtkWidget* widget, GtkStateFlags previousStateFlags) stateFlagsChanged; 11241 /** */ 11242 extern(C) void function(GtkWidget* widget, GtkWidget* previousParent) parentSet; 11243 /** */ 11244 extern(C) void function(GtkWidget* widget, GtkWidget* previousToplevel) hierarchyChanged; 11245 /** */ 11246 extern(C) void function(GtkWidget* widget, GtkStyle* previousStyle) styleSet; 11247 /** */ 11248 extern(C) void function(GtkWidget* widget, GtkTextDirection previousDirection) directionChanged; 11249 /** */ 11250 extern(C) void function(GtkWidget* widget, int wasGrabbed) grabNotify; 11251 /** */ 11252 extern(C) void function(GtkWidget* widget, GParamSpec* childProperty) childNotify; 11253 /** */ 11254 extern(C) int function(GtkWidget* widget, cairo_t* cr) draw; 11255 /** 11256 * 11257 * Params: 11258 * widget = a #GtkWidget instance 11259 * Returns: The #GtkSizeRequestMode preferred by @widget. 11260 */ 11261 extern(C) GtkSizeRequestMode function(GtkWidget* widget) getRequestMode; 11262 /** */ 11263 extern(C) void function(GtkWidget* widget, int* minimumHeight, int* naturalHeight) getPreferredHeight; 11264 /** */ 11265 extern(C) void function(GtkWidget* widget, int height, int* minimumWidth, int* naturalWidth) getPreferredWidthForHeight; 11266 /** */ 11267 extern(C) void function(GtkWidget* widget, int* minimumWidth, int* naturalWidth) getPreferredWidth; 11268 /** */ 11269 extern(C) void function(GtkWidget* widget, int width, int* minimumHeight, int* naturalHeight) getPreferredHeightForWidth; 11270 /** 11271 * 11272 * Params: 11273 * widget = a #GtkWidget 11274 * groupCycling = %TRUE if there are other widgets with the same mnemonic 11275 * Returns: %TRUE if the signal has been handled 11276 */ 11277 extern(C) int function(GtkWidget* widget, int groupCycling) mnemonicActivate; 11278 /** */ 11279 extern(C) void function(GtkWidget* widget) grabFocus; 11280 /** */ 11281 extern(C) int function(GtkWidget* widget, GtkDirectionType direction) focus; 11282 /** */ 11283 extern(C) void function(GtkWidget* widget, GtkDirectionType direction) moveFocus; 11284 /** 11285 * 11286 * Params: 11287 * widget = a #GtkWidget 11288 * direction = direction of focus movement 11289 * Returns: %TRUE if stopping keyboard navigation is fine, %FALSE 11290 * if the emitting widget should try to handle the keyboard 11291 * navigation attempt in its parent container(s). 11292 */ 11293 extern(C) int function(GtkWidget* widget, GtkDirectionType direction) keynavFailed; 11294 /** 11295 * 11296 * Params: 11297 * widget = a #GtkWidget 11298 * event = a #GdkEvent 11299 * Returns: return from the event signal emission (%TRUE if 11300 * the event was handled) 11301 */ 11302 extern(C) int function(GtkWidget* widget, GdkEvent* event) event; 11303 /** */ 11304 extern(C) int function(GtkWidget* widget, GdkEventButton* event) buttonPressEvent; 11305 /** */ 11306 extern(C) int function(GtkWidget* widget, GdkEventButton* event) buttonReleaseEvent; 11307 /** */ 11308 extern(C) int function(GtkWidget* widget, GdkEventScroll* event) scrollEvent; 11309 /** */ 11310 extern(C) int function(GtkWidget* widget, GdkEventMotion* event) motionNotifyEvent; 11311 /** */ 11312 extern(C) int function(GtkWidget* widget, GdkEventAny* event) deleteEvent; 11313 /** */ 11314 extern(C) int function(GtkWidget* widget, GdkEventAny* event) destroyEvent; 11315 /** */ 11316 extern(C) int function(GtkWidget* widget, GdkEventKey* event) keyPressEvent; 11317 /** */ 11318 extern(C) int function(GtkWidget* widget, GdkEventKey* event) keyReleaseEvent; 11319 /** */ 11320 extern(C) int function(GtkWidget* widget, GdkEventCrossing* event) enterNotifyEvent; 11321 /** */ 11322 extern(C) int function(GtkWidget* widget, GdkEventCrossing* event) leaveNotifyEvent; 11323 /** */ 11324 extern(C) int function(GtkWidget* widget, GdkEventConfigure* event) configureEvent; 11325 /** */ 11326 extern(C) int function(GtkWidget* widget, GdkEventFocus* event) focusInEvent; 11327 /** */ 11328 extern(C) int function(GtkWidget* widget, GdkEventFocus* event) focusOutEvent; 11329 /** */ 11330 extern(C) int function(GtkWidget* widget, GdkEventAny* event) mapEvent; 11331 /** */ 11332 extern(C) int function(GtkWidget* widget, GdkEventAny* event) unmapEvent; 11333 /** */ 11334 extern(C) int function(GtkWidget* widget, GdkEventProperty* event) propertyNotifyEvent; 11335 /** */ 11336 extern(C) int function(GtkWidget* widget, GdkEventSelection* event) selectionClearEvent; 11337 /** */ 11338 extern(C) int function(GtkWidget* widget, GdkEventSelection* event) selectionRequestEvent; 11339 /** */ 11340 extern(C) int function(GtkWidget* widget, GdkEventSelection* event) selectionNotifyEvent; 11341 /** */ 11342 extern(C) int function(GtkWidget* widget, GdkEventProximity* event) proximityInEvent; 11343 /** */ 11344 extern(C) int function(GtkWidget* widget, GdkEventProximity* event) proximityOutEvent; 11345 /** */ 11346 extern(C) int function(GtkWidget* widget, GdkEventVisibility* event) visibilityNotifyEvent; 11347 /** */ 11348 extern(C) int function(GtkWidget* widget, GdkEventWindowState* event) windowStateEvent; 11349 /** */ 11350 extern(C) int function(GtkWidget* widget, GdkEventExpose* event) damageEvent; 11351 /** */ 11352 extern(C) int function(GtkWidget* widget, GdkEventGrabBroken* event) grabBrokenEvent; 11353 /** */ 11354 extern(C) void function(GtkWidget* widget, GtkSelectionData* selectionData, uint info, uint time) selectionGet; 11355 /** */ 11356 extern(C) void function(GtkWidget* widget, GtkSelectionData* selectionData, uint time) selectionReceived; 11357 /** */ 11358 extern(C) void function(GtkWidget* widget, GdkDragContext* context) dragBegin; 11359 /** */ 11360 extern(C) void function(GtkWidget* widget, GdkDragContext* context) dragEnd; 11361 /** */ 11362 extern(C) void function(GtkWidget* widget, GdkDragContext* context, GtkSelectionData* selectionData, uint info, uint time) dragDataGet; 11363 /** */ 11364 extern(C) void function(GtkWidget* widget, GdkDragContext* context) dragDataDelete; 11365 /** */ 11366 extern(C) void function(GtkWidget* widget, GdkDragContext* context, uint time) dragLeave; 11367 /** */ 11368 extern(C) int function(GtkWidget* widget, GdkDragContext* context, int x, int y, uint time) dragMotion; 11369 /** */ 11370 extern(C) int function(GtkWidget* widget, GdkDragContext* context, int x, int y, uint time) dragDrop; 11371 /** */ 11372 extern(C) void function(GtkWidget* widget, GdkDragContext* context, int x, int y, GtkSelectionData* selectionData, uint info, uint time) dragDataReceived; 11373 /** */ 11374 extern(C) int function(GtkWidget* widget, GdkDragContext* context, GtkDragResult result) dragFailed; 11375 /** */ 11376 extern(C) int function(GtkWidget* widget) popupMenu; 11377 /** */ 11378 extern(C) int function(GtkWidget* widget, GtkWidgetHelpType helpType) showHelp; 11379 /** 11380 * 11381 * Params: 11382 * widget = a #GtkWidget 11383 * Returns: the #AtkObject associated with @widget 11384 */ 11385 extern(C) AtkObject* function(GtkWidget* widget) getAccessible; 11386 /** */ 11387 extern(C) void function(GtkWidget* widget, GdkScreen* previousScreen) screenChanged; 11388 /** 11389 * 11390 * Params: 11391 * widget = a #GtkWidget 11392 * signalId = the ID of a signal installed on @widget 11393 * Returns: %TRUE if the accelerator can be activated. 11394 */ 11395 extern(C) int function(GtkWidget* widget, uint signalId) canActivateAccel; 11396 /** */ 11397 extern(C) void function(GtkWidget* widget) compositedChanged; 11398 /** */ 11399 extern(C) int function(GtkWidget* widget, int x, int y, int keyboardTooltip, GtkTooltip* tooltip) queryTooltip; 11400 /** */ 11401 extern(C) void function(GtkWidget* widget, int* hexpandP, int* vexpandP) computeExpand; 11402 /** */ 11403 extern(C) void function(GtkWidget* widget, GtkOrientation orientation, int* minimumSize, int* naturalSize) adjustSizeRequest; 11404 /** */ 11405 extern(C) void function(GtkWidget* widget, GtkOrientation orientation, int* minimumSize, int* naturalSize, int* allocatedPos, int* allocatedSize) adjustSizeAllocation; 11406 /** */ 11407 extern(C) void function(GtkWidget* widget) styleUpdated; 11408 /** */ 11409 extern(C) int function(GtkWidget* widget, GdkEventTouch* event) touchEvent; 11410 /** */ 11411 extern(C) void function(GtkWidget* widget, int width, int* minimumHeight, int* naturalHeight, int* minimumBaseline, int* naturalBaseline) getPreferredHeightAndBaselineForWidth; 11412 /** */ 11413 extern(C) void function(GtkWidget* widget, int* minimumBaseline, int* naturalBaseline) adjustBaselineRequest; 11414 /** */ 11415 extern(C) void function(GtkWidget* widget, int* baseline) adjustBaselineAllocation; 11416 /** */ 11417 extern(C) void function(GtkWidget* widget, cairo_region_t* region) queueDrawRegion; 11418 GtkWidgetClassPrivate* priv; 11419 /** */ 11420 extern(C) void function() GtkReserved6; 11421 /** */ 11422 extern(C) void function() GtkReserved7; 11423 } 11424 11425 struct GtkWidgetClassPrivate; 11426 11427 struct GtkWidgetPath; 11428 11429 struct GtkWidgetPrivate; 11430 11431 struct GtkWindow 11432 { 11433 GtkBin bin; 11434 GtkWindowPrivate* priv; 11435 } 11436 11437 struct GtkWindowAccessible 11438 { 11439 GtkContainerAccessible parent; 11440 GtkWindowAccessiblePrivate* priv; 11441 } 11442 11443 struct GtkWindowAccessibleClass 11444 { 11445 GtkContainerAccessibleClass parentClass; 11446 } 11447 11448 struct GtkWindowAccessiblePrivate; 11449 11450 struct GtkWindowClass 11451 { 11452 /** 11453 * The parent class. 11454 */ 11455 GtkBinClass parentClass; 11456 /** */ 11457 extern(C) void function(GtkWindow* window, GtkWidget* focus) setFocus; 11458 /** */ 11459 extern(C) void function(GtkWindow* window) activateFocus; 11460 /** */ 11461 extern(C) void function(GtkWindow* window) activateDefault; 11462 /** */ 11463 extern(C) void function(GtkWindow* window) keysChanged; 11464 /** */ 11465 extern(C) int function(GtkWindow* window, int toggle) enableDebugging; 11466 /** */ 11467 extern(C) void function() GtkReserved1; 11468 /** */ 11469 extern(C) void function() GtkReserved2; 11470 /** */ 11471 extern(C) void function() GtkReserved3; 11472 } 11473 11474 struct GtkWindowGeometryInfo; 11475 11476 struct GtkWindowGroup 11477 { 11478 GObject parentInstance; 11479 GtkWindowGroupPrivate* priv; 11480 } 11481 11482 struct GtkWindowGroupClass 11483 { 11484 GObjectClass parentClass; 11485 /** */ 11486 extern(C) void function() GtkReserved1; 11487 /** */ 11488 extern(C) void function() GtkReserved2; 11489 /** */ 11490 extern(C) void function() GtkReserved3; 11491 /** */ 11492 extern(C) void function() GtkReserved4; 11493 } 11494 11495 struct GtkWindowGroupPrivate; 11496 11497 struct GtkWindowPrivate; 11498 11499 /** */ 11500 public alias extern(C) int function(GtkAccelGroup* accelGroup, GObject* acceleratable, uint keyval, GdkModifierType modifier) GtkAccelGroupActivate; 11501 11502 /** */ 11503 public alias extern(C) int function(GtkAccelKey* key, GClosure* closure, void* data) GtkAccelGroupFindFunc; 11504 11505 /** */ 11506 public alias extern(C) void function(void* data, const(char)* accelPath, uint accelKey, GdkModifierType accelMods, int changed) GtkAccelMapForeach; 11507 11508 /** 11509 * A function used by gtk_assistant_set_forward_page_func() to know which 11510 * is the next page given a current one. It’s called both for computing the 11511 * next page when the user presses the “forward” button and for handling 11512 * the behavior of the “last” button. 11513 * 11514 * Params: 11515 * currentPage = The page number used to calculate the next page. 11516 * data = user data. 11517 * 11518 * Returns: The next page number. 11519 */ 11520 public alias extern(C) int function(int currentPage, void* data) GtkAssistantPageFunc; 11521 11522 /** 11523 * This is the signature of a function used to connect signals. It is used 11524 * by the gtk_builder_connect_signals() and gtk_builder_connect_signals_full() 11525 * methods. It is mainly intended for interpreted language bindings, but 11526 * could be useful where the programmer wants more control over the signal 11527 * connection process. Note that this function can only be called once, 11528 * subsequent calls will do nothing. 11529 * 11530 * Params: 11531 * builder = a #GtkBuilder 11532 * object = object to connect a signal to 11533 * signalName = name of the signal 11534 * handlerName = name of the handler 11535 * connectObject = a #GObject, if non-%NULL, use g_signal_connect_object() 11536 * flags = #GConnectFlags to use 11537 * userData = user data 11538 * 11539 * Since: 2.12 11540 */ 11541 public alias extern(C) void function(GtkBuilder* builder, GObject* object, const(char)* signalName, const(char)* handlerName, GObject* connectObject, GConnectFlags flags, void* userData) GtkBuilderConnectFunc; 11542 11543 /** 11544 * This kind of functions provide Pango markup with detail information for the 11545 * specified day. Examples for such details are holidays or appointments. The 11546 * function returns %NULL when no information is available. 11547 * 11548 * Params: 11549 * calendar = a #GtkCalendar. 11550 * year = the year for which details are needed. 11551 * month = the month for which details are needed. 11552 * day = the day of @month for which details are needed. 11553 * userData = the data passed with gtk_calendar_set_detail_func(). 11554 * 11555 * Returns: Newly allocated string with Pango markup 11556 * with details for the specified day or %NULL. 11557 * 11558 * Since: 2.14 11559 */ 11560 public alias extern(C) char* function(GtkCalendar* calendar, uint year, uint month, uint day, void* userData) GtkCalendarDetailFunc; 11561 11562 /** 11563 * The type of the callback functions used for e.g. iterating over 11564 * the children of a container, see gtk_container_foreach(). 11565 * 11566 * Params: 11567 * widget = the widget to operate on 11568 * data = user-supplied data 11569 */ 11570 public alias extern(C) void function(GtkWidget* widget, void* data) GtkCallback; 11571 11572 /** 11573 * The type of the callback functions used for iterating over the 11574 * cell renderers and their allocated areas inside a #GtkCellArea, 11575 * see gtk_cell_area_foreach_alloc(). 11576 * 11577 * Params: 11578 * renderer = the cell renderer to operate on 11579 * cellArea = the area allocated to @renderer inside the rectangle 11580 * provided to gtk_cell_area_foreach_alloc(). 11581 * cellBackground = the background area for @renderer inside the 11582 * background area provided to gtk_cell_area_foreach_alloc(). 11583 * data = user-supplied data 11584 * 11585 * Returns: %TRUE to stop iterating over cells. 11586 */ 11587 public alias extern(C) int function(GtkCellRenderer* renderer, GdkRectangle* cellArea, GdkRectangle* cellBackground, void* data) GtkCellAllocCallback; 11588 11589 /** 11590 * The type of the callback functions used for iterating over 11591 * the cell renderers of a #GtkCellArea, see gtk_cell_area_foreach(). 11592 * 11593 * Params: 11594 * renderer = the cell renderer to operate on 11595 * data = user-supplied data 11596 * 11597 * Returns: %TRUE to stop iterating over cells. 11598 */ 11599 public alias extern(C) int function(GtkCellRenderer* renderer, void* data) GtkCellCallback; 11600 11601 /** 11602 * A function which should set the value of @cell_layout’s cell renderer(s) 11603 * as appropriate. 11604 * 11605 * Params: 11606 * cellLayout = a #GtkCellLayout 11607 * cell = the cell renderer whose value is to be set 11608 * treeModel = the model 11609 * iter = a #GtkTreeIter indicating the row to set the value for 11610 * data = user data passed to gtk_cell_layout_set_cell_data_func() 11611 */ 11612 public alias extern(C) void function(GtkCellLayout* cellLayout, GtkCellRenderer* cell, GtkTreeModel* treeModel, GtkTreeIter* iter, void* data) GtkCellLayoutDataFunc; 11613 11614 /** 11615 * A function that will be called when the contents of the clipboard are changed 11616 * or cleared. Once this has called, the @user_data_or_owner argument 11617 * will not be used again. 11618 * 11619 * Params: 11620 * clipboard = the #GtkClipboard 11621 * userDataOrOwner = the @user_data argument passed to gtk_clipboard_set_with_data(), 11622 * or the @owner argument passed to gtk_clipboard_set_with_owner() 11623 */ 11624 public alias extern(C) void function(GtkClipboard* clipboard, void* userDataOrOwner) GtkClipboardClearFunc; 11625 11626 /** 11627 * A function that will be called to provide the contents of the selection. 11628 * If multiple types of data were advertised, the requested type can 11629 * be determined from the @info parameter or by checking the target field 11630 * of @selection_data. If the data could successfully be converted into 11631 * then it should be stored into the @selection_data object by 11632 * calling gtk_selection_data_set() (or related functions such 11633 * as gtk_selection_data_set_text()). If no data is set, the requestor 11634 * will be informed that the attempt to get the data failed. 11635 * 11636 * Params: 11637 * clipboard = the #GtkClipboard 11638 * selectionData = a #GtkSelectionData argument in which the requested 11639 * data should be stored. 11640 * info = the info field corresponding to the requested target from the 11641 * #GtkTargetEntry array passed to gtk_clipboard_set_with_data() or 11642 * gtk_clipboard_set_with_owner(). 11643 * userDataOrOwner = the @user_data argument passed to 11644 * gtk_clipboard_set_with_data(), or the @owner argument passed to 11645 * gtk_clipboard_set_with_owner() 11646 */ 11647 public alias extern(C) void function(GtkClipboard* clipboard, GtkSelectionData* selectionData, uint info, void* userDataOrOwner) GtkClipboardGetFunc; 11648 11649 /** 11650 * A function to be called when the results of gtk_clipboard_request_image() 11651 * are received, or when the request fails. 11652 * 11653 * Params: 11654 * clipboard = the #GtkClipboard 11655 * pixbuf = the received image 11656 * data = the @user_data supplied to 11657 * gtk_clipboard_request_image(). 11658 * 11659 * Since: 2.6 11660 */ 11661 public alias extern(C) void function(GtkClipboard* clipboard, GdkPixbuf* pixbuf, void* data) GtkClipboardImageReceivedFunc; 11662 11663 /** 11664 * A function to be called when the results of gtk_clipboard_request_contents() 11665 * are received, or when the request fails. 11666 * 11667 * Params: 11668 * clipboard = the #GtkClipboard 11669 * selectionData = a #GtkSelectionData containing the data was received. 11670 * If retrieving the data failed, then then length field 11671 * of @selection_data will be negative. 11672 * data = the @user_data supplied to 11673 * gtk_clipboard_request_contents(). 11674 */ 11675 public alias extern(C) void function(GtkClipboard* clipboard, GtkSelectionData* selectionData, void* data) GtkClipboardReceivedFunc; 11676 11677 /** 11678 * A function to be called when the results of 11679 * gtk_clipboard_request_rich_text() are received, or when the request 11680 * fails. 11681 * 11682 * Params: 11683 * clipboard = the #GtkClipboard 11684 * format = The format of the rich text 11685 * text = the rich text received, as 11686 * a UTF-8 encoded string, or %NULL if retrieving the data failed. 11687 * length = Length of the text. 11688 * data = the @user_data supplied to 11689 * gtk_clipboard_request_rich_text(). 11690 * 11691 * Since: 2.10 11692 */ 11693 public alias extern(C) void function(GtkClipboard* clipboard, GdkAtom format, ubyte* text, size_t length, void* data) GtkClipboardRichTextReceivedFunc; 11694 11695 /** 11696 * A function to be called when the results of gtk_clipboard_request_targets() 11697 * are received, or when the request fails. 11698 * 11699 * Params: 11700 * clipboard = the #GtkClipboard 11701 * atoms = the supported targets, 11702 * as array of #GdkAtom, or %NULL if retrieving the data failed. 11703 * nAtoms = the length of the @atoms array. 11704 * data = the @user_data supplied to 11705 * gtk_clipboard_request_targets(). 11706 * 11707 * Since: 2.4 11708 */ 11709 public alias extern(C) void function(GtkClipboard* clipboard, GdkAtom* atoms, int nAtoms, void* data) GtkClipboardTargetsReceivedFunc; 11710 11711 /** 11712 * A function to be called when the results of gtk_clipboard_request_text() 11713 * are received, or when the request fails. 11714 * 11715 * Params: 11716 * clipboard = the #GtkClipboard 11717 * text = the text received, as a UTF-8 encoded string, or 11718 * %NULL if retrieving the data failed. 11719 * data = the @user_data supplied to 11720 * gtk_clipboard_request_text(). 11721 */ 11722 public alias extern(C) void function(GtkClipboard* clipboard, const(char)* text, void* data) GtkClipboardTextReceivedFunc; 11723 11724 /** 11725 * A function to be called when the results of 11726 * gtk_clipboard_request_uris() are received, or when the request 11727 * fails. 11728 * 11729 * Params: 11730 * clipboard = the #GtkClipboard 11731 * uris = the received URIs 11732 * data = the @user_data supplied to 11733 * gtk_clipboard_request_uris(). 11734 * 11735 * Since: 2.14 11736 */ 11737 public alias extern(C) void function(GtkClipboard* clipboard, char** uris, void* data) GtkClipboardURIReceivedFunc; 11738 11739 /** */ 11740 public alias extern(C) void function(GdkColor* colors, int nColors) GtkColorSelectionChangePaletteFunc; 11741 11742 /** */ 11743 public alias extern(C) void function(GdkScreen* screen, GdkColor* colors, int nColors) GtkColorSelectionChangePaletteWithScreenFunc; 11744 11745 /** 11746 * A function which decides whether the row indicated by @iter matches 11747 * a given @key, and should be displayed as a possible completion for @key. 11748 * Note that @key is normalized and case-folded (see g_utf8_normalize() 11749 * and g_utf8_casefold()). If this is not appropriate, match functions 11750 * have access to the unmodified key via 11751 * `gtk_entry_get_text (GTK_ENTRY (gtk_entry_completion_get_entry ()))`. 11752 * 11753 * Params: 11754 * completion = the #GtkEntryCompletion 11755 * key = the string to match, normalized and case-folded 11756 * iter = a #GtkTreeIter indicating the row to match 11757 * userData = user data given to gtk_entry_completion_set_match_func() 11758 * 11759 * Returns: %TRUE if @iter should be displayed as a possible completion 11760 * for @key 11761 */ 11762 public alias extern(C) int function(GtkEntryCompletion* completion, const(char)* key, GtkTreeIter* iter, void* userData) GtkEntryCompletionMatchFunc; 11763 11764 /** 11765 * The type of function that is used with custom filters, see 11766 * gtk_file_filter_add_custom(). 11767 * 11768 * Params: 11769 * filterInfo = a #GtkFileFilterInfo that is filled according 11770 * to the @needed flags passed to gtk_file_filter_add_custom() 11771 * data = user data passed to gtk_file_filter_add_custom() 11772 * 11773 * Returns: %TRUE if the file should be displayed 11774 */ 11775 public alias extern(C) int function(GtkFileFilterInfo* filterInfo, void* data) GtkFileFilterFunc; 11776 11777 /** 11778 * Called for flow boxes that are bound to a #GListModel with 11779 * gtk_flow_box_bind_model() for each item that gets added to the model. 11780 * 11781 * Params: 11782 * item = the item from the model for which to create a widget for 11783 * userData = user data from gtk_flow_box_bind_model() 11784 * 11785 * Returns: a #GtkWidget that represents @item 11786 * 11787 * Since: 3.18 11788 */ 11789 public alias extern(C) GtkWidget* function(void* item, void* userData) GtkFlowBoxCreateWidgetFunc; 11790 11791 /** 11792 * A function that will be called whenrever a child changes 11793 * or is added. It lets you control if the child should be 11794 * visible or not. 11795 * 11796 * Params: 11797 * child = a #GtkFlowBoxChild that may be filtered 11798 * userData = user data 11799 * 11800 * Returns: %TRUE if the row should be visible, %FALSE otherwise 11801 * 11802 * Since: 3.12 11803 */ 11804 public alias extern(C) int function(GtkFlowBoxChild* child, void* userData) GtkFlowBoxFilterFunc; 11805 11806 /** 11807 * A function used by gtk_flow_box_selected_foreach(). 11808 * It will be called on every selected child of the @box. 11809 * 11810 * Params: 11811 * box = a #GtkFlowBox 11812 * child = a #GtkFlowBoxChild 11813 * userData = user data 11814 * 11815 * Since: 3.12 11816 */ 11817 public alias extern(C) void function(GtkFlowBox* box, GtkFlowBoxChild* child, void* userData) GtkFlowBoxForeachFunc; 11818 11819 /** 11820 * A function to compare two children to determine which 11821 * should come first. 11822 * 11823 * Params: 11824 * child1 = the first child 11825 * child2 = the second child 11826 * userData = user data 11827 * 11828 * Returns: < 0 if @child1 should be before @child2, 0 if 11829 * the are equal, and > 0 otherwise 11830 * 11831 * Since: 3.12 11832 */ 11833 public alias extern(C) int function(GtkFlowBoxChild* child1, GtkFlowBoxChild* child2, void* userData) GtkFlowBoxSortFunc; 11834 11835 /** 11836 * The type of function that is used for deciding what fonts get 11837 * shown in a #GtkFontChooser. See gtk_font_chooser_set_filter_func(). 11838 * 11839 * Params: 11840 * family = a #PangoFontFamily 11841 * face = a #PangoFontFace belonging to @family 11842 * data = user data passed to gtk_font_chooser_set_filter_func() 11843 * 11844 * Returns: %TRUE if the font should be displayed 11845 */ 11846 public alias extern(C) int function(PangoFontFamily* family, PangoFontFace* face, void* data) GtkFontFilterFunc; 11847 11848 /** 11849 * A function used by gtk_icon_view_selected_foreach() to map all 11850 * selected rows. It will be called on every selected row in the view. 11851 * 11852 * Params: 11853 * iconView = a #GtkIconView 11854 * path = The #GtkTreePath of a selected row 11855 * data = user data 11856 */ 11857 public alias extern(C) void function(GtkIconView* iconView, GtkTreePath* path, void* data) GtkIconViewForeachFunc; 11858 11859 /** 11860 * Key snooper functions are called before normal event delivery. 11861 * They can be used to implement custom key event handling. 11862 * 11863 * Params: 11864 * grabWidget = the widget to which the event will be delivered 11865 * event = the key event 11866 * funcData = data supplied to gtk_key_snooper_install() 11867 * 11868 * Returns: %TRUE to stop further processing of @event, %FALSE to continue. 11869 */ 11870 public alias extern(C) int function(GtkWidget* grabWidget, GdkEventKey* event, void* funcData) GtkKeySnoopFunc; 11871 11872 /** 11873 * Called for list boxes that are bound to a #GListModel with 11874 * gtk_list_box_bind_model() for each item that gets added to the model. 11875 * 11876 * Versions of GTK+ prior to 3.18 called gtk_widget_show_all() on the rows 11877 * created by the GtkListBoxCreateWidgetFunc, but this forced all widgets 11878 * inside the row to be shown, and is no longer the case. Applications should 11879 * be updated to show the desired row widgets. 11880 * 11881 * Params: 11882 * item = the item from the model for which to create a widget for 11883 * userData = user data 11884 * 11885 * Returns: a #GtkWidget that represents @item 11886 * 11887 * Since: 3.16 11888 */ 11889 public alias extern(C) GtkWidget* function(void* item, void* userData) GtkListBoxCreateWidgetFunc; 11890 11891 /** 11892 * Will be called whenever the row changes or is added and lets you control 11893 * if the row should be visible or not. 11894 * 11895 * Params: 11896 * row = the row that may be filtered 11897 * userData = user data 11898 * 11899 * Returns: %TRUE if the row should be visible, %FALSE otherwise 11900 * 11901 * Since: 3.10 11902 */ 11903 public alias extern(C) int function(GtkListBoxRow* row, void* userData) GtkListBoxFilterFunc; 11904 11905 /** 11906 * A function used by gtk_list_box_selected_foreach(). 11907 * It will be called on every selected child of the @box. 11908 * 11909 * Params: 11910 * box = a #GtkListBox 11911 * row = a #GtkListBoxRow 11912 * userData = user data 11913 * 11914 * Since: 3.14 11915 */ 11916 public alias extern(C) void function(GtkListBox* box, GtkListBoxRow* row, void* userData) GtkListBoxForeachFunc; 11917 11918 /** 11919 * Compare two rows to determine which should be first. 11920 * 11921 * Params: 11922 * row1 = the first row 11923 * row2 = the second row 11924 * userData = user data 11925 * 11926 * Returns: < 0 if @row1 should be before @row2, 0 if they are 11927 * equal and > 0 otherwise 11928 * 11929 * Since: 3.10 11930 */ 11931 public alias extern(C) int function(GtkListBoxRow* row1, GtkListBoxRow* row2, void* userData) GtkListBoxSortFunc; 11932 11933 /** 11934 * Whenever @row changes or which row is before @row changes this 11935 * is called, which lets you update the header on @row. You may 11936 * remove or set a new one via gtk_list_box_row_set_header() or 11937 * just change the state of the current header widget. 11938 * 11939 * Params: 11940 * row = the row to update 11941 * before = the row before @row, or %NULL if it is first 11942 * userData = user data 11943 * 11944 * Since: 3.10 11945 */ 11946 public alias extern(C) void function(GtkListBoxRow* row, GtkListBoxRow* before, void* userData) GtkListBoxUpdateHeaderFunc; 11947 11948 /** 11949 * A user function supplied when calling gtk_menu_attach_to_widget() which 11950 * will be called when the menu is later detached from the widget. 11951 * 11952 * Params: 11953 * attachWidget = the #GtkWidget that the menu is being detached from. 11954 * menu = the #GtkMenu being detached. 11955 */ 11956 public alias extern(C) void function(GtkWidget* attachWidget, GtkMenu* menu) GtkMenuDetachFunc; 11957 11958 /** 11959 * A user function supplied when calling gtk_menu_popup() which 11960 * controls the positioning of the menu when it is displayed. The 11961 * function sets the @x and @y parameters to the coordinates where the 11962 * menu is to be drawn. To make the menu appear on a different 11963 * monitor than the mouse pointer, gtk_menu_set_monitor() must be 11964 * called. 11965 * 11966 * Params: 11967 * menu = a #GtkMenu. 11968 * x = address of the #gint representing the horizontal 11969 * position where the menu shall be drawn. 11970 * y = address of the #gint representing the vertical position 11971 * where the menu shall be drawn. This is an output parameter. 11972 * pushIn = This parameter controls how menus placed outside 11973 * the monitor are handled. If this is set to %TRUE and part of 11974 * the menu is outside the monitor then GTK+ pushes the window 11975 * into the visible area, effectively modifying the popup 11976 * position. Note that moving and possibly resizing the menu 11977 * around will alter the scroll position to keep the menu items 11978 * “in place”, i.e. at the same monitor position they would have 11979 * been without resizing. In practice, this behavior is only 11980 * useful for combobox popups or option menus and cannot be used 11981 * to simply confine a menu to monitor boundaries. In that case, 11982 * changing the scroll offset is not desirable. 11983 * userData = the data supplied by the user in the gtk_menu_popup() 11984 * @data parameter. 11985 */ 11986 public alias extern(C) void function(GtkMenu* menu, int* x, int* y, int* pushIn, void* userData) GtkMenuPositionFunc; 11987 11988 /** 11989 * A multihead-aware GTK+ module may have a gtk_module_display_init() function 11990 * with this prototype. GTK+ calls this function for each opened display. 11991 * 11992 * Params: 11993 * display = an open #GdkDisplay 11994 * 11995 * Since: 2.2 11996 */ 11997 public alias extern(C) void function(GdkDisplay* display) GtkModuleDisplayInitFunc; 11998 11999 /** 12000 * Each GTK+ module must have a function gtk_module_init() with this prototype. 12001 * This function is called after loading the module. 12002 * 12003 * Params: 12004 * argc = GTK+ always passes %NULL for this argument 12005 * argv = GTK+ always passes %NULL for this argument 12006 */ 12007 public alias extern(C) void function(int* argc, char*** argv) GtkModuleInitFunc; 12008 12009 /** 12010 * The type of function that is passed to 12011 * gtk_print_run_page_setup_dialog_async(). 12012 * 12013 * This function will be called when the page setup dialog 12014 * is dismissed, and also serves as destroy notify for @data. 12015 * 12016 * Params: 12017 * pageSetup = the #GtkPageSetup that has been 12018 * data = user data that has been passed to 12019 * gtk_print_run_page_setup_dialog_async() 12020 */ 12021 public alias extern(C) void function(GtkPageSetup* pageSetup, void* data) GtkPageSetupDoneFunc; 12022 12023 /** */ 12024 public alias extern(C) void function(const(char)* key, const(char)* value, void* userData) GtkPrintSettingsFunc; 12025 12026 /** */ 12027 public alias extern(C) int function(GParamSpec* pspec, GString* rcString, GValue* propertyValue) GtkRcPropertyParser; 12028 12029 /** 12030 * The type of function that is used with custom filters, 12031 * see gtk_recent_filter_add_custom(). 12032 * 12033 * Params: 12034 * filterInfo = a #GtkRecentFilterInfo that is filled according 12035 * to the @needed flags passed to gtk_recent_filter_add_custom() 12036 * userData = user data passed to gtk_recent_filter_add_custom() 12037 * 12038 * Returns: %TRUE if the file should be displayed 12039 */ 12040 public alias extern(C) int function(GtkRecentFilterInfo* filterInfo, void* userData) GtkRecentFilterFunc; 12041 12042 /** */ 12043 public alias extern(C) int function(GtkRecentInfo* a, GtkRecentInfo* b, void* userData) GtkRecentSortFunc; 12044 12045 /** */ 12046 public alias extern(C) int function(const(char)* str, GValue* value, GError** err) GtkStylePropertyParser; 12047 12048 /** 12049 * A function that is called to deserialize rich text that has been 12050 * serialized with gtk_text_buffer_serialize(), and insert it at @iter. 12051 * 12052 * Params: 12053 * registerBuffer = the #GtkTextBuffer the format is registered with 12054 * contentBuffer = the #GtkTextBuffer to deserialize into 12055 * iter = insertion point for the deserialized text 12056 * data = data to deserialize 12057 * length = length of @data 12058 * createTags = %TRUE if deserializing may create tags 12059 * userData = user data that was specified when registering the format 12060 * 12061 * Returns: %TRUE on success, %FALSE otherwise 12062 * 12063 * Throws: GException on failure. 12064 */ 12065 public alias extern(C) int function(GtkTextBuffer* registerBuffer, GtkTextBuffer* contentBuffer, GtkTextIter* iter, ubyte* data, size_t length, int createTags, void* userData, GError** err) GtkTextBufferDeserializeFunc; 12066 12067 /** 12068 * A function that is called to serialize the content of a text buffer. 12069 * It must return the serialized form of the content. 12070 * 12071 * Params: 12072 * registerBuffer = the #GtkTextBuffer for which the format is registered 12073 * contentBuffer = the #GtkTextBuffer to serialize 12074 * start = start of the block of text to serialize 12075 * end = end of the block of text to serialize 12076 * length = Return location for the length of the serialized data 12077 * userData = user data that was specified when registering the format 12078 * 12079 * Returns: a newly-allocated array of guint8 which contains 12080 * the serialized data, or %NULL if an error occurred 12081 */ 12082 public alias extern(C) ubyte* function(GtkTextBuffer* registerBuffer, GtkTextBuffer* contentBuffer, GtkTextIter* start, GtkTextIter* end, size_t* length, void* userData) GtkTextBufferSerializeFunc; 12083 12084 /** */ 12085 public alias extern(C) int function(dchar ch, void* userData) GtkTextCharPredicate; 12086 12087 /** */ 12088 public alias extern(C) void function(GtkTextTag* tag, void* data) GtkTextTagTableForeach; 12089 12090 /** 12091 * Callback type for adding a function to update animations. See gtk_widget_add_tick_callback(). 12092 * 12093 * Params: 12094 * widget = the widget 12095 * frameClock = the frame clock for the widget (same as calling gtk_widget_get_frame_clock()) 12096 * userData = user data passed to gtk_widget_add_tick_callback(). 12097 * 12098 * Returns: %G_SOURCE_CONTINUE if the tick callback should continue to be called, 12099 * %G_SOURCE_REMOVE if the tick callback should be removed. 12100 * 12101 * Since: 3.8 12102 */ 12103 public alias extern(C) int function(GtkWidget* widget, GdkFrameClock* frameClock, void* userData) GtkTickCallback; 12104 12105 /** 12106 * The function used to translate messages in e.g. #GtkIconFactory 12107 * and #GtkActionGroup. 12108 * 12109 * Params: 12110 * path = The id of the message. In #GtkActionGroup this will be a label 12111 * or tooltip from a #GtkActionEntry. 12112 * funcData = user data passed in when registering the 12113 * function 12114 * 12115 * Returns: the translated message 12116 */ 12117 public alias extern(C) char* function(const(char)* path, void* funcData) GtkTranslateFunc; 12118 12119 /** 12120 * A function to set the properties of a cell instead of just using the 12121 * straight mapping between the cell and the model. This is useful for 12122 * customizing the cell renderer. For example, a function might get an 12123 * integer from the @tree_model, and render it to the “text” attribute of 12124 * “cell” by converting it to its written equivalent. This is set by 12125 * calling gtk_tree_view_column_set_cell_data_func() 12126 * 12127 * Params: 12128 * treeColumn = A #GtkTreeViewColumn 12129 * cell = The #GtkCellRenderer that is being rendered by @tree_column 12130 * treeModel = The #GtkTreeModel being rendered 12131 * iter = A #GtkTreeIter of the current row rendered 12132 * data = user data 12133 */ 12134 public alias extern(C) void function(GtkTreeViewColumn* treeColumn, GtkCellRenderer* cell, GtkTreeModel* treeModel, GtkTreeIter* iter, void* data) GtkTreeCellDataFunc; 12135 12136 /** */ 12137 public alias extern(C) void function(GtkTreeView* treeView, GtkTreePath* path, int children, void* userData) GtkTreeDestroyCountFunc; 12138 12139 /** 12140 * A GtkTreeIterCompareFunc should return a negative integer, zero, or a positive 12141 * integer if @a sorts before @b, @a sorts with @b, or @a sorts after @b 12142 * respectively. If two iters compare as equal, their order in the sorted model 12143 * is undefined. In order to ensure that the #GtkTreeSortable behaves as 12144 * expected, the GtkTreeIterCompareFunc must define a partial order on 12145 * the model, i.e. it must be reflexive, antisymmetric and transitive. 12146 * 12147 * For example, if @model is a product catalogue, then a compare function 12148 * for the “price” column could be one which returns 12149 * `price_of(@a) - price_of(@b)`. 12150 * 12151 * Params: 12152 * model = The #GtkTreeModel the comparison is within 12153 * a = A #GtkTreeIter in @model 12154 * b = Another #GtkTreeIter in @model 12155 * userData = Data passed when the compare func is assigned e.g. by 12156 * gtk_tree_sortable_set_sort_func() 12157 * 12158 * Returns: a negative integer, zero or a positive integer depending on whether 12159 * @a sorts before, with or after @b 12160 */ 12161 public alias extern(C) int function(GtkTreeModel* model, GtkTreeIter* a, GtkTreeIter* b, void* userData) GtkTreeIterCompareFunc; 12162 12163 /** 12164 * A function which calculates display values from raw values in the model. 12165 * It must fill @value with the display value for the column @column in the 12166 * row indicated by @iter. 12167 * 12168 * Since this function is called for each data access, it’s not a 12169 * particularly efficient operation. 12170 * 12171 * Params: 12172 * model = the #GtkTreeModelFilter 12173 * iter = a #GtkTreeIter pointing to the row whose display values are determined 12174 * value = A #GValue which is already initialized for 12175 * with the correct type for the column @column. 12176 * column = the column whose display value is determined 12177 * data = user data given to gtk_tree_model_filter_set_modify_func() 12178 */ 12179 public alias extern(C) void function(GtkTreeModel* model, GtkTreeIter* iter, GValue* value, int column, void* data) GtkTreeModelFilterModifyFunc; 12180 12181 /** 12182 * A function which decides whether the row indicated by @iter is visible. 12183 * 12184 * Params: 12185 * model = the child model of the #GtkTreeModelFilter 12186 * iter = a #GtkTreeIter pointing to the row in @model whose visibility 12187 * is determined 12188 * data = user data given to gtk_tree_model_filter_set_visible_func() 12189 * 12190 * Returns: Whether the row indicated by @iter is visible. 12191 */ 12192 public alias extern(C) int function(GtkTreeModel* model, GtkTreeIter* iter, void* data) GtkTreeModelFilterVisibleFunc; 12193 12194 /** 12195 * Type of the callback passed to gtk_tree_model_foreach() to 12196 * iterate over the rows in a tree model. 12197 * 12198 * Params: 12199 * model = the #GtkTreeModel being iterated 12200 * path = the current #GtkTreePath 12201 * iter = the current #GtkTreeIter 12202 * data = The user data passed to gtk_tree_model_foreach() 12203 * 12204 * Returns: %TRUE to stop iterating, %FALSE to continue 12205 */ 12206 public alias extern(C) int function(GtkTreeModel* model, GtkTreePath* path, GtkTreeIter* iter, void* data) GtkTreeModelForeachFunc; 12207 12208 /** 12209 * A function used by gtk_tree_selection_selected_foreach() to map all 12210 * selected rows. It will be called on every selected row in the view. 12211 * 12212 * Params: 12213 * model = The #GtkTreeModel being viewed 12214 * path = The #GtkTreePath of a selected row 12215 * iter = A #GtkTreeIter pointing to a selected row 12216 * data = user data 12217 */ 12218 public alias extern(C) void function(GtkTreeModel* model, GtkTreePath* path, GtkTreeIter* iter, void* data) GtkTreeSelectionForeachFunc; 12219 12220 /** 12221 * A function used by gtk_tree_selection_set_select_function() to filter 12222 * whether or not a row may be selected. It is called whenever a row's 12223 * state might change. A return value of %TRUE indicates to @selection 12224 * that it is okay to change the selection. 12225 * 12226 * Params: 12227 * selection = A #GtkTreeSelection 12228 * model = A #GtkTreeModel being viewed 12229 * path = The #GtkTreePath of the row in question 12230 * pathCurrentlySelected = %TRUE, if the path is currently selected 12231 * data = user data 12232 * 12233 * Returns: %TRUE, if the selection state of the row can be toggled 12234 */ 12235 public alias extern(C) int function(GtkTreeSelection* selection, GtkTreeModel* model, GtkTreePath* path, int pathCurrentlySelected, void* data) GtkTreeSelectionFunc; 12236 12237 /** 12238 * Function type for determining whether @column can be dropped in a 12239 * particular spot (as determined by @prev_column and @next_column). In 12240 * left to right locales, @prev_column is on the left of the potential drop 12241 * spot, and @next_column is on the right. In right to left mode, this is 12242 * reversed. This function should return %TRUE if the spot is a valid drop 12243 * spot. Please note that returning %TRUE does not actually indicate that 12244 * the column drop was made, but is meant only to indicate a possible drop 12245 * spot to the user. 12246 * 12247 * Params: 12248 * treeView = A #GtkTreeView 12249 * column = The #GtkTreeViewColumn being dragged 12250 * prevColumn = A #GtkTreeViewColumn on one side of @column 12251 * nextColumn = A #GtkTreeViewColumn on the other side of @column 12252 * data = user data 12253 * 12254 * Returns: %TRUE, if @column can be dropped in this spot 12255 */ 12256 public alias extern(C) int function(GtkTreeView* treeView, GtkTreeViewColumn* column, GtkTreeViewColumn* prevColumn, GtkTreeViewColumn* nextColumn, void* data) GtkTreeViewColumnDropFunc; 12257 12258 /** 12259 * Function used for gtk_tree_view_map_expanded_rows(). 12260 * 12261 * Params: 12262 * treeView = A #GtkTreeView 12263 * path = The path that’s expanded 12264 * userData = user data 12265 */ 12266 public alias extern(C) void function(GtkTreeView* treeView, GtkTreePath* path, void* userData) GtkTreeViewMappingFunc; 12267 12268 /** 12269 * Function type for determining whether the row pointed to by @iter should 12270 * be rendered as a separator. A common way to implement this is to have a 12271 * boolean column in the model, whose values the #GtkTreeViewRowSeparatorFunc 12272 * returns. 12273 * 12274 * Params: 12275 * model = the #GtkTreeModel 12276 * iter = a #GtkTreeIter pointing at a row in @model 12277 * data = user data 12278 * 12279 * Returns: %TRUE if the row is a separator 12280 */ 12281 public alias extern(C) int function(GtkTreeModel* model, GtkTreeIter* iter, void* data) GtkTreeViewRowSeparatorFunc; 12282 12283 /** 12284 * A function used for checking whether a row in @model matches 12285 * a search key string entered by the user. Note the return value 12286 * is reversed from what you would normally expect, though it 12287 * has some similarity to strcmp() returning 0 for equal strings. 12288 * 12289 * Params: 12290 * model = the #GtkTreeModel being searched 12291 * column = the search column set by gtk_tree_view_set_search_column() 12292 * key = the key string to compare with 12293 * iter = a #GtkTreeIter pointing the row of @model that should be compared 12294 * with @key. 12295 * searchData = user data from gtk_tree_view_set_search_equal_func() 12296 * 12297 * Returns: %FALSE if the row matches, %TRUE otherwise. 12298 */ 12299 public alias extern(C) int function(GtkTreeModel* model, int column, const(char)* key, GtkTreeIter* iter, void* searchData) GtkTreeViewSearchEqualFunc; 12300 12301 /** */ 12302 public alias extern(C) void function(GtkTreeView* treeView, GtkWidget* searchDialog, void* userData) GtkTreeViewSearchPositionFunc; 12303 12304 /** 12305 * Like gtk_get_binary_age(), but from the headers used at 12306 * application compile time, rather than from the library linked 12307 * against at application run time. 12308 */ 12309 enum BINARY_AGE = 2224; 12310 alias GTK_BINARY_AGE = BINARY_AGE; 12311 12312 /** 12313 * Constant to return from a signal handler for the #GtkSpinButton::input 12314 * signal in case of conversion failure. 12315 */ 12316 enum INPUT_ERROR = -1; 12317 alias GTK_INPUT_ERROR = INPUT_ERROR; 12318 12319 /** 12320 * Like gtk_get_interface_age(), but from the headers used at 12321 * application compile time, rather than from the library linked 12322 * against at application run time. 12323 */ 12324 enum INTERFACE_AGE = 24; 12325 alias GTK_INTERFACE_AGE = INTERFACE_AGE; 12326 12327 /** 12328 * The name used for the stock full offset included by #GtkLevelBar. 12329 */ 12330 enum LEVEL_BAR_OFFSET_FULL = "full"; 12331 alias GTK_LEVEL_BAR_OFFSET_FULL = LEVEL_BAR_OFFSET_FULL; 12332 12333 /** 12334 * The name used for the stock high offset included by #GtkLevelBar. 12335 */ 12336 enum LEVEL_BAR_OFFSET_HIGH = "high"; 12337 alias GTK_LEVEL_BAR_OFFSET_HIGH = LEVEL_BAR_OFFSET_HIGH; 12338 12339 /** 12340 * The name used for the stock low offset included by #GtkLevelBar. 12341 */ 12342 enum LEVEL_BAR_OFFSET_LOW = "low"; 12343 alias GTK_LEVEL_BAR_OFFSET_LOW = LEVEL_BAR_OFFSET_LOW; 12344 12345 /** 12346 * Like gtk_get_major_version(), but from the headers used at 12347 * application compile time, rather than from the library linked 12348 * against at application run time. 12349 */ 12350 enum MAJOR_VERSION = 3; 12351 alias GTK_MAJOR_VERSION = MAJOR_VERSION; 12352 12353 /** 12354 * The maximum length of sequences in compose tables. 12355 */ 12356 enum MAX_COMPOSE_LEN = 7; 12357 alias GTK_MAX_COMPOSE_LEN = MAX_COMPOSE_LEN; 12358 12359 /** 12360 * Like gtk_get_micro_version(), but from the headers used at 12361 * application compile time, rather than from the library linked 12362 * against at application run time. 12363 */ 12364 enum MICRO_VERSION = 24; 12365 alias GTK_MICRO_VERSION = MICRO_VERSION; 12366 12367 /** 12368 * Like gtk_get_minor_version(), but from the headers used at 12369 * application compile time, rather than from the library linked 12370 * against at application run time. 12371 */ 12372 enum MINOR_VERSION = 22; 12373 alias GTK_MINOR_VERSION = MINOR_VERSION; 12374 12375 /** 12376 * Name for the A3 paper size. 12377 */ 12378 enum PAPER_NAME_A3 = "iso_a3"; 12379 alias GTK_PAPER_NAME_A3 = PAPER_NAME_A3; 12380 12381 /** 12382 * Name for the A4 paper size. 12383 */ 12384 enum PAPER_NAME_A4 = "iso_a4"; 12385 alias GTK_PAPER_NAME_A4 = PAPER_NAME_A4; 12386 12387 /** 12388 * Name for the A5 paper size. 12389 */ 12390 enum PAPER_NAME_A5 = "iso_a5"; 12391 alias GTK_PAPER_NAME_A5 = PAPER_NAME_A5; 12392 12393 /** 12394 * Name for the B5 paper size. 12395 */ 12396 enum PAPER_NAME_B5 = "iso_b5"; 12397 alias GTK_PAPER_NAME_B5 = PAPER_NAME_B5; 12398 12399 /** 12400 * Name for the Executive paper size. 12401 */ 12402 enum PAPER_NAME_EXECUTIVE = "na_executive"; 12403 alias GTK_PAPER_NAME_EXECUTIVE = PAPER_NAME_EXECUTIVE; 12404 12405 /** 12406 * Name for the Legal paper size. 12407 */ 12408 enum PAPER_NAME_LEGAL = "na_legal"; 12409 alias GTK_PAPER_NAME_LEGAL = PAPER_NAME_LEGAL; 12410 12411 /** 12412 * Name for the Letter paper size. 12413 */ 12414 enum PAPER_NAME_LETTER = "na_letter"; 12415 alias GTK_PAPER_NAME_LETTER = PAPER_NAME_LETTER; 12416 12417 enum PATH_PRIO_MASK = 15; 12418 alias GTK_PATH_PRIO_MASK = PATH_PRIO_MASK; 12419 12420 enum PRINT_SETTINGS_COLLATE = "collate"; 12421 alias GTK_PRINT_SETTINGS_COLLATE = PRINT_SETTINGS_COLLATE; 12422 12423 enum PRINT_SETTINGS_DEFAULT_SOURCE = "default-source"; 12424 alias GTK_PRINT_SETTINGS_DEFAULT_SOURCE = PRINT_SETTINGS_DEFAULT_SOURCE; 12425 12426 enum PRINT_SETTINGS_DITHER = "dither"; 12427 alias GTK_PRINT_SETTINGS_DITHER = PRINT_SETTINGS_DITHER; 12428 12429 enum PRINT_SETTINGS_DUPLEX = "duplex"; 12430 alias GTK_PRINT_SETTINGS_DUPLEX = PRINT_SETTINGS_DUPLEX; 12431 12432 enum PRINT_SETTINGS_FINISHINGS = "finishings"; 12433 alias GTK_PRINT_SETTINGS_FINISHINGS = PRINT_SETTINGS_FINISHINGS; 12434 12435 enum PRINT_SETTINGS_MEDIA_TYPE = "media-type"; 12436 alias GTK_PRINT_SETTINGS_MEDIA_TYPE = PRINT_SETTINGS_MEDIA_TYPE; 12437 12438 enum PRINT_SETTINGS_NUMBER_UP = "number-up"; 12439 alias GTK_PRINT_SETTINGS_NUMBER_UP = PRINT_SETTINGS_NUMBER_UP; 12440 12441 enum PRINT_SETTINGS_NUMBER_UP_LAYOUT = "number-up-layout"; 12442 alias GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT = PRINT_SETTINGS_NUMBER_UP_LAYOUT; 12443 12444 enum PRINT_SETTINGS_N_COPIES = "n-copies"; 12445 alias GTK_PRINT_SETTINGS_N_COPIES = PRINT_SETTINGS_N_COPIES; 12446 12447 enum PRINT_SETTINGS_ORIENTATION = "orientation"; 12448 alias GTK_PRINT_SETTINGS_ORIENTATION = PRINT_SETTINGS_ORIENTATION; 12449 12450 /** 12451 * The key used by the “Print to file” printer to store the file 12452 * name of the output without the path to the directory and the 12453 * file extension. 12454 */ 12455 enum PRINT_SETTINGS_OUTPUT_BASENAME = "output-basename"; 12456 alias GTK_PRINT_SETTINGS_OUTPUT_BASENAME = PRINT_SETTINGS_OUTPUT_BASENAME; 12457 12458 enum PRINT_SETTINGS_OUTPUT_BIN = "output-bin"; 12459 alias GTK_PRINT_SETTINGS_OUTPUT_BIN = PRINT_SETTINGS_OUTPUT_BIN; 12460 12461 /** 12462 * The key used by the “Print to file” printer to store the 12463 * directory to which the output should be written. 12464 */ 12465 enum PRINT_SETTINGS_OUTPUT_DIR = "output-dir"; 12466 alias GTK_PRINT_SETTINGS_OUTPUT_DIR = PRINT_SETTINGS_OUTPUT_DIR; 12467 12468 /** 12469 * The key used by the “Print to file” printer to store the format 12470 * of the output. The supported values are “PS” and “PDF”. 12471 */ 12472 enum PRINT_SETTINGS_OUTPUT_FILE_FORMAT = "output-file-format"; 12473 alias GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT = PRINT_SETTINGS_OUTPUT_FILE_FORMAT; 12474 12475 /** 12476 * The key used by the “Print to file” printer to store the URI 12477 * to which the output should be written. GTK+ itself supports 12478 * only “file://” URIs. 12479 */ 12480 enum PRINT_SETTINGS_OUTPUT_URI = "output-uri"; 12481 alias GTK_PRINT_SETTINGS_OUTPUT_URI = PRINT_SETTINGS_OUTPUT_URI; 12482 12483 enum PRINT_SETTINGS_PAGE_RANGES = "page-ranges"; 12484 alias GTK_PRINT_SETTINGS_PAGE_RANGES = PRINT_SETTINGS_PAGE_RANGES; 12485 12486 enum PRINT_SETTINGS_PAGE_SET = "page-set"; 12487 alias GTK_PRINT_SETTINGS_PAGE_SET = PRINT_SETTINGS_PAGE_SET; 12488 12489 enum PRINT_SETTINGS_PAPER_FORMAT = "paper-format"; 12490 alias GTK_PRINT_SETTINGS_PAPER_FORMAT = PRINT_SETTINGS_PAPER_FORMAT; 12491 12492 enum PRINT_SETTINGS_PAPER_HEIGHT = "paper-height"; 12493 alias GTK_PRINT_SETTINGS_PAPER_HEIGHT = PRINT_SETTINGS_PAPER_HEIGHT; 12494 12495 enum PRINT_SETTINGS_PAPER_WIDTH = "paper-width"; 12496 alias GTK_PRINT_SETTINGS_PAPER_WIDTH = PRINT_SETTINGS_PAPER_WIDTH; 12497 12498 enum PRINT_SETTINGS_PRINTER = "printer"; 12499 alias GTK_PRINT_SETTINGS_PRINTER = PRINT_SETTINGS_PRINTER; 12500 12501 enum PRINT_SETTINGS_PRINTER_LPI = "printer-lpi"; 12502 alias GTK_PRINT_SETTINGS_PRINTER_LPI = PRINT_SETTINGS_PRINTER_LPI; 12503 12504 enum PRINT_SETTINGS_PRINT_PAGES = "print-pages"; 12505 alias GTK_PRINT_SETTINGS_PRINT_PAGES = PRINT_SETTINGS_PRINT_PAGES; 12506 12507 enum PRINT_SETTINGS_QUALITY = "quality"; 12508 alias GTK_PRINT_SETTINGS_QUALITY = PRINT_SETTINGS_QUALITY; 12509 12510 enum PRINT_SETTINGS_RESOLUTION = "resolution"; 12511 alias GTK_PRINT_SETTINGS_RESOLUTION = PRINT_SETTINGS_RESOLUTION; 12512 12513 enum PRINT_SETTINGS_RESOLUTION_X = "resolution-x"; 12514 alias GTK_PRINT_SETTINGS_RESOLUTION_X = PRINT_SETTINGS_RESOLUTION_X; 12515 12516 enum PRINT_SETTINGS_RESOLUTION_Y = "resolution-y"; 12517 alias GTK_PRINT_SETTINGS_RESOLUTION_Y = PRINT_SETTINGS_RESOLUTION_Y; 12518 12519 enum PRINT_SETTINGS_REVERSE = "reverse"; 12520 alias GTK_PRINT_SETTINGS_REVERSE = PRINT_SETTINGS_REVERSE; 12521 12522 enum PRINT_SETTINGS_SCALE = "scale"; 12523 alias GTK_PRINT_SETTINGS_SCALE = PRINT_SETTINGS_SCALE; 12524 12525 enum PRINT_SETTINGS_USE_COLOR = "use-color"; 12526 alias GTK_PRINT_SETTINGS_USE_COLOR = PRINT_SETTINGS_USE_COLOR; 12527 12528 enum PRINT_SETTINGS_WIN32_DRIVER_EXTRA = "win32-driver-extra"; 12529 alias GTK_PRINT_SETTINGS_WIN32_DRIVER_EXTRA = PRINT_SETTINGS_WIN32_DRIVER_EXTRA; 12530 12531 enum PRINT_SETTINGS_WIN32_DRIVER_VERSION = "win32-driver-version"; 12532 alias GTK_PRINT_SETTINGS_WIN32_DRIVER_VERSION = PRINT_SETTINGS_WIN32_DRIVER_VERSION; 12533 12534 /** 12535 * Use this priority for functionality related to size allocation. 12536 * 12537 * It is used internally by GTK+ to compute the sizes of widgets. 12538 * This priority is higher than %GDK_PRIORITY_REDRAW to avoid 12539 * resizing a widget which was just redrawn. 12540 */ 12541 enum PRIORITY_RESIZE = 10; 12542 alias GTK_PRIORITY_RESIZE = PRIORITY_RESIZE; 12543 12544 /** 12545 * A CSS class to match an accelerator. 12546 * 12547 * Refer to individual widget documentation for used style classes. 12548 */ 12549 enum STYLE_CLASS_ACCELERATOR = "accelerator"; 12550 alias GTK_STYLE_CLASS_ACCELERATOR = STYLE_CLASS_ACCELERATOR; 12551 12552 /** 12553 * A CSS class used when rendering an arrow element. 12554 * 12555 * Refer to individual widget documentation for used style classes. 12556 */ 12557 enum STYLE_CLASS_ARROW = "arrow"; 12558 alias GTK_STYLE_CLASS_ARROW = STYLE_CLASS_ARROW; 12559 12560 /** 12561 * A CSS class to match the window background. 12562 * 12563 * Refer to individual widget documentation for used style classes. 12564 */ 12565 enum STYLE_CLASS_BACKGROUND = "background"; 12566 alias GTK_STYLE_CLASS_BACKGROUND = STYLE_CLASS_BACKGROUND; 12567 12568 /** 12569 * A CSS class to indicate an area at the bottom of a widget. 12570 * 12571 * Refer to individual widget documentation for used style classes. 12572 */ 12573 enum STYLE_CLASS_BOTTOM = "bottom"; 12574 alias GTK_STYLE_CLASS_BOTTOM = STYLE_CLASS_BOTTOM; 12575 12576 /** 12577 * A CSS class to match buttons. 12578 * 12579 * Refer to individual widget documentation for used style classes. 12580 */ 12581 enum STYLE_CLASS_BUTTON = "button"; 12582 alias GTK_STYLE_CLASS_BUTTON = STYLE_CLASS_BUTTON; 12583 12584 /** 12585 * A CSS class to match calendars. 12586 * 12587 * Refer to individual widget documentation for used style classes. 12588 */ 12589 enum STYLE_CLASS_CALENDAR = "calendar"; 12590 alias GTK_STYLE_CLASS_CALENDAR = STYLE_CLASS_CALENDAR; 12591 12592 /** 12593 * A CSS class to match content rendered in cell views. 12594 * 12595 * Refer to individual widget documentation for used style classes. 12596 */ 12597 enum STYLE_CLASS_CELL = "cell"; 12598 alias GTK_STYLE_CLASS_CELL = STYLE_CLASS_CELL; 12599 12600 /** 12601 * A CSS class to match check boxes. 12602 * 12603 * Refer to individual widget documentation for used style classes. 12604 */ 12605 enum STYLE_CLASS_CHECK = "check"; 12606 alias GTK_STYLE_CLASS_CHECK = STYLE_CLASS_CHECK; 12607 12608 /** 12609 * A CSS class to match combobox entries. 12610 * 12611 * Refer to individual widget documentation for used style classes. 12612 */ 12613 enum STYLE_CLASS_COMBOBOX_ENTRY = "combobox-entry"; 12614 alias GTK_STYLE_CLASS_COMBOBOX_ENTRY = STYLE_CLASS_COMBOBOX_ENTRY; 12615 12616 /** 12617 * A CSS class to match context menus. 12618 * 12619 * Refer to individual widget documentation for used style classes. 12620 */ 12621 enum STYLE_CLASS_CONTEXT_MENU = "context-menu"; 12622 alias GTK_STYLE_CLASS_CONTEXT_MENU = STYLE_CLASS_CONTEXT_MENU; 12623 12624 /** 12625 * A CSS class that gets added to windows which have client-side decorations. 12626 * 12627 * Refer to individual widget documentation for used style classes. 12628 */ 12629 enum STYLE_CLASS_CSD = "csd"; 12630 alias GTK_STYLE_CLASS_CSD = STYLE_CLASS_CSD; 12631 12632 /** 12633 * A CSS class used when rendering a drag handle for 12634 * text selection. 12635 * 12636 * Refer to individual widget documentation for used style classes. 12637 */ 12638 enum STYLE_CLASS_CURSOR_HANDLE = "cursor-handle"; 12639 alias GTK_STYLE_CLASS_CURSOR_HANDLE = STYLE_CLASS_CURSOR_HANDLE; 12640 12641 /** 12642 * A CSS class to match the default widget. 12643 * 12644 * Refer to individual widget documentation for used style classes. 12645 */ 12646 enum STYLE_CLASS_DEFAULT = "default"; 12647 alias GTK_STYLE_CLASS_DEFAULT = STYLE_CLASS_DEFAULT; 12648 12649 /** 12650 * A CSS class used when an action (usually a button) is 12651 * one that is expected to remove or destroy something visible 12652 * to the user. 12653 * 12654 * Refer to individual widget documentation for used style classes. 12655 */ 12656 enum STYLE_CLASS_DESTRUCTIVE_ACTION = "destructive-action"; 12657 alias GTK_STYLE_CLASS_DESTRUCTIVE_ACTION = STYLE_CLASS_DESTRUCTIVE_ACTION; 12658 12659 /** 12660 * A CSS class to match dimmed labels. 12661 * 12662 * Refer to individual widget documentation for used style classes. 12663 */ 12664 enum STYLE_CLASS_DIM_LABEL = "dim-label"; 12665 alias GTK_STYLE_CLASS_DIM_LABEL = STYLE_CLASS_DIM_LABEL; 12666 12667 /** 12668 * A CSS class for a drag-and-drop indicator. 12669 * 12670 * Refer to individual widget documentation for used style classes. 12671 */ 12672 enum STYLE_CLASS_DND = "dnd"; 12673 alias GTK_STYLE_CLASS_DND = STYLE_CLASS_DND; 12674 12675 /** 12676 * A CSS class defining a dock area. 12677 * 12678 * Refer to individual widget documentation for used style classes. 12679 */ 12680 enum STYLE_CLASS_DOCK = "dock"; 12681 alias GTK_STYLE_CLASS_DOCK = STYLE_CLASS_DOCK; 12682 12683 /** 12684 * A CSS class to match text entries. 12685 * 12686 * Refer to individual widget documentation for used style classes. 12687 */ 12688 enum STYLE_CLASS_ENTRY = "entry"; 12689 alias GTK_STYLE_CLASS_ENTRY = STYLE_CLASS_ENTRY; 12690 12691 /** 12692 * A CSS class for an area displaying an error message, 12693 * such as those in infobars. 12694 * 12695 * Refer to individual widget documentation for used style classes. 12696 */ 12697 enum STYLE_CLASS_ERROR = "error"; 12698 alias GTK_STYLE_CLASS_ERROR = STYLE_CLASS_ERROR; 12699 12700 /** 12701 * A CSS class defining an expander, such as those in treeviews. 12702 * 12703 * Refer to individual widget documentation for used style classes. 12704 */ 12705 enum STYLE_CLASS_EXPANDER = "expander"; 12706 alias GTK_STYLE_CLASS_EXPANDER = STYLE_CLASS_EXPANDER; 12707 12708 /** 12709 * A CSS class that is added when widgets that usually have 12710 * a frame or border (like buttons or entries) should appear 12711 * without it. 12712 * 12713 * Refer to individual widget documentation for used style classes. 12714 */ 12715 enum STYLE_CLASS_FLAT = "flat"; 12716 alias GTK_STYLE_CLASS_FLAT = STYLE_CLASS_FLAT; 12717 12718 /** 12719 * A CSS class defining a frame delimiting content, such as 12720 * #GtkFrame or the scrolled window frame around the 12721 * scrollable area. 12722 * 12723 * Refer to individual widget documentation for used style classes. 12724 */ 12725 enum STYLE_CLASS_FRAME = "frame"; 12726 alias GTK_STYLE_CLASS_FRAME = STYLE_CLASS_FRAME; 12727 12728 /** 12729 * A CSS class defining a resize grip. 12730 * 12731 * Refer to individual widget documentation for used style classes. 12732 */ 12733 enum STYLE_CLASS_GRIP = "grip"; 12734 alias GTK_STYLE_CLASS_GRIP = STYLE_CLASS_GRIP; 12735 12736 /** 12737 * A CSS class to match a header element. 12738 * 12739 * Refer to individual widget documentation for used style classes. 12740 */ 12741 enum STYLE_CLASS_HEADER = "header"; 12742 alias GTK_STYLE_CLASS_HEADER = STYLE_CLASS_HEADER; 12743 12744 /** 12745 * A CSS class defining a highlighted area, such as headings in 12746 * assistants and calendars. 12747 * 12748 * Refer to individual widget documentation for used style classes. 12749 */ 12750 enum STYLE_CLASS_HIGHLIGHT = "highlight"; 12751 alias GTK_STYLE_CLASS_HIGHLIGHT = STYLE_CLASS_HIGHLIGHT; 12752 12753 /** 12754 * A CSS class for horizontally layered widgets. 12755 * 12756 * Refer to individual widget documentation for used style classes. 12757 */ 12758 enum STYLE_CLASS_HORIZONTAL = "horizontal"; 12759 alias GTK_STYLE_CLASS_HORIZONTAL = STYLE_CLASS_HORIZONTAL; 12760 12761 /** 12762 * A CSS class defining an image, such as the icon in an entry. 12763 * 12764 * Refer to individual widget documentation for used style classes. 12765 */ 12766 enum STYLE_CLASS_IMAGE = "image"; 12767 alias GTK_STYLE_CLASS_IMAGE = STYLE_CLASS_IMAGE; 12768 12769 /** 12770 * A CSS class for an area displaying an informational message, 12771 * such as those in infobars. 12772 * 12773 * Refer to individual widget documentation for used style classes. 12774 */ 12775 enum STYLE_CLASS_INFO = "info"; 12776 alias GTK_STYLE_CLASS_INFO = STYLE_CLASS_INFO; 12777 12778 /** 12779 * A CSS class to match inline toolbars. 12780 * 12781 * Refer to individual widget documentation for used style classes. 12782 */ 12783 enum STYLE_CLASS_INLINE_TOOLBAR = "inline-toolbar"; 12784 alias GTK_STYLE_CLASS_INLINE_TOOLBAR = STYLE_CLASS_INLINE_TOOLBAR; 12785 12786 /** 12787 * A CSS class used when rendering a drag handle for 12788 * the insertion cursor position. 12789 * 12790 * Refer to individual widget documentation for used style classes. 12791 */ 12792 enum STYLE_CLASS_INSERTION_CURSOR = "insertion-cursor"; 12793 alias GTK_STYLE_CLASS_INSERTION_CURSOR = STYLE_CLASS_INSERTION_CURSOR; 12794 12795 /** 12796 * A CSS class to match labels. 12797 * 12798 * Refer to individual widget documentation for used style classes. 12799 */ 12800 enum STYLE_CLASS_LABEL = "label"; 12801 alias GTK_STYLE_CLASS_LABEL = STYLE_CLASS_LABEL; 12802 12803 /** 12804 * A CSS class to indicate an area at the left of a widget. 12805 * 12806 * Refer to individual widget documentation for used style classes. 12807 */ 12808 enum STYLE_CLASS_LEFT = "left"; 12809 alias GTK_STYLE_CLASS_LEFT = STYLE_CLASS_LEFT; 12810 12811 /** 12812 * A CSS class used when rendering a level indicator, such 12813 * as a battery charge level, or a password strength. 12814 * 12815 * Refer to individual widget documentation for used style classes. 12816 */ 12817 enum STYLE_CLASS_LEVEL_BAR = "level-bar"; 12818 alias GTK_STYLE_CLASS_LEVEL_BAR = STYLE_CLASS_LEVEL_BAR; 12819 12820 /** 12821 * A CSS class to match a linked area, such as a box containing buttons 12822 * belonging to the same control. 12823 * 12824 * Refer to individual widget documentation for used style classes. 12825 */ 12826 enum STYLE_CLASS_LINKED = "linked"; 12827 alias GTK_STYLE_CLASS_LINKED = STYLE_CLASS_LINKED; 12828 12829 /** 12830 * A CSS class to match lists. 12831 * 12832 * Refer to individual widget documentation for used style classes. 12833 */ 12834 enum STYLE_CLASS_LIST = "list"; 12835 alias GTK_STYLE_CLASS_LIST = STYLE_CLASS_LIST; 12836 12837 /** 12838 * A CSS class to match list rows. 12839 * 12840 * Refer to individual widget documentation for used style classes. 12841 */ 12842 enum STYLE_CLASS_LIST_ROW = "list-row"; 12843 alias GTK_STYLE_CLASS_LIST_ROW = STYLE_CLASS_LIST_ROW; 12844 12845 /** 12846 * A CSS class defining marks in a widget, such as in scales. 12847 * 12848 * Refer to individual widget documentation for used style classes. 12849 */ 12850 enum STYLE_CLASS_MARK = "mark"; 12851 alias GTK_STYLE_CLASS_MARK = STYLE_CLASS_MARK; 12852 12853 /** 12854 * A CSS class to match menus. 12855 * 12856 * Refer to individual widget documentation for used style classes. 12857 */ 12858 enum STYLE_CLASS_MENU = "menu"; 12859 alias GTK_STYLE_CLASS_MENU = STYLE_CLASS_MENU; 12860 12861 /** 12862 * A CSS class to menubars. 12863 * 12864 * Refer to individual widget documentation for used style classes. 12865 */ 12866 enum STYLE_CLASS_MENUBAR = "menubar"; 12867 alias GTK_STYLE_CLASS_MENUBAR = STYLE_CLASS_MENUBAR; 12868 12869 /** 12870 * A CSS class to match menu items. 12871 * 12872 * Refer to individual widget documentation for used style classes. 12873 */ 12874 enum STYLE_CLASS_MENUITEM = "menuitem"; 12875 alias GTK_STYLE_CLASS_MENUITEM = STYLE_CLASS_MENUITEM; 12876 12877 /** 12878 * A CSS class that is added to message dialogs. 12879 * 12880 * Refer to individual widget documentation for used style classes. 12881 */ 12882 enum STYLE_CLASS_MESSAGE_DIALOG = "message-dialog"; 12883 alias GTK_STYLE_CLASS_MESSAGE_DIALOG = STYLE_CLASS_MESSAGE_DIALOG; 12884 12885 /** 12886 * A CSS class that is added to text view that should use 12887 * a monospace font. 12888 * 12889 * Refer to individual widget documentation for used style classes. 12890 */ 12891 enum STYLE_CLASS_MONOSPACE = "monospace"; 12892 alias GTK_STYLE_CLASS_MONOSPACE = STYLE_CLASS_MONOSPACE; 12893 12894 /** 12895 * A CSS class used when an element needs the user attention, 12896 * for instance a button in a stack switcher corresponding to 12897 * a hidden page that changed state. 12898 * 12899 * Refer to individual widget documentation for used style classes. 12900 */ 12901 enum STYLE_CLASS_NEEDS_ATTENTION = "needs-attention"; 12902 alias GTK_STYLE_CLASS_NEEDS_ATTENTION = STYLE_CLASS_NEEDS_ATTENTION; 12903 12904 /** 12905 * A CSS class defining a notebook. 12906 * 12907 * Refer to individual widget documentation for used style classes. 12908 */ 12909 enum STYLE_CLASS_NOTEBOOK = "notebook"; 12910 alias GTK_STYLE_CLASS_NOTEBOOK = STYLE_CLASS_NOTEBOOK; 12911 12912 /** 12913 * A CSS class used when rendering an OSD (On Screen Display) element, 12914 * on top of another container. 12915 * 12916 * Refer to individual widget documentation for used style classes. 12917 */ 12918 enum STYLE_CLASS_OSD = "osd"; 12919 alias GTK_STYLE_CLASS_OSD = STYLE_CLASS_OSD; 12920 12921 /** 12922 * A CSS class that is added on the visual hints that happen 12923 * when scrolling is attempted past the limits of a scrollable 12924 * area. 12925 * 12926 * Refer to individual widget documentation for used style classes. 12927 */ 12928 enum STYLE_CLASS_OVERSHOOT = "overshoot"; 12929 alias GTK_STYLE_CLASS_OVERSHOOT = STYLE_CLASS_OVERSHOOT; 12930 12931 /** 12932 * A CSS class for a pane separator, such as those in #GtkPaned. 12933 * 12934 * Refer to individual widget documentation for used style classes. 12935 */ 12936 enum STYLE_CLASS_PANE_SEPARATOR = "pane-separator"; 12937 alias GTK_STYLE_CLASS_PANE_SEPARATOR = STYLE_CLASS_PANE_SEPARATOR; 12938 12939 /** 12940 * A CSS class that is added to areas that should look like paper. 12941 * 12942 * This is used in print previews and themes are encouraged to 12943 * style it as black text on white background. 12944 * 12945 * Refer to individual widget documentation for used style classes. 12946 */ 12947 enum STYLE_CLASS_PAPER = "paper"; 12948 alias GTK_STYLE_CLASS_PAPER = STYLE_CLASS_PAPER; 12949 12950 /** 12951 * A CSS class that matches popovers. 12952 * 12953 * Refer to individual widget documentation for used style classes. 12954 */ 12955 enum STYLE_CLASS_POPOVER = "popover"; 12956 alias GTK_STYLE_CLASS_POPOVER = STYLE_CLASS_POPOVER; 12957 12958 /** 12959 * A CSS class that is added to the toplevel windows used for menus. 12960 * 12961 * Refer to individual widget documentation for used style classes. 12962 */ 12963 enum STYLE_CLASS_POPUP = "popup"; 12964 alias GTK_STYLE_CLASS_POPUP = STYLE_CLASS_POPUP; 12965 12966 /** 12967 * A CSS class to match primary toolbars. 12968 * 12969 * Refer to individual widget documentation for used style classes. 12970 */ 12971 enum STYLE_CLASS_PRIMARY_TOOLBAR = "primary-toolbar"; 12972 alias GTK_STYLE_CLASS_PRIMARY_TOOLBAR = STYLE_CLASS_PRIMARY_TOOLBAR; 12973 12974 /** 12975 * A CSS class to use when rendering activity as a progressbar. 12976 * 12977 * Refer to individual widget documentation for used style classes. 12978 */ 12979 enum STYLE_CLASS_PROGRESSBAR = "progressbar"; 12980 alias GTK_STYLE_CLASS_PROGRESSBAR = STYLE_CLASS_PROGRESSBAR; 12981 12982 /** 12983 * A CSS class to use when rendering a pulse in an indeterminate progress bar. 12984 * 12985 * Refer to individual widget documentation for used style classes. 12986 */ 12987 enum STYLE_CLASS_PULSE = "pulse"; 12988 alias GTK_STYLE_CLASS_PULSE = STYLE_CLASS_PULSE; 12989 12990 /** 12991 * A CSS class for an area displaying a question to the user, 12992 * such as those in infobars. 12993 * 12994 * Refer to individual widget documentation for used style classes. 12995 */ 12996 enum STYLE_CLASS_QUESTION = "question"; 12997 alias GTK_STYLE_CLASS_QUESTION = STYLE_CLASS_QUESTION; 12998 12999 /** 13000 * A CSS class to match radio buttons. 13001 * 13002 * Refer to individual widget documentation for used style classes. 13003 */ 13004 enum STYLE_CLASS_RADIO = "radio"; 13005 alias GTK_STYLE_CLASS_RADIO = STYLE_CLASS_RADIO; 13006 13007 /** 13008 * A CSS class to match a raised control, such as a raised 13009 * button on a toolbar. 13010 * 13011 * Refer to individual widget documentation for used style classes. 13012 */ 13013 enum STYLE_CLASS_RAISED = "raised"; 13014 alias GTK_STYLE_CLASS_RAISED = STYLE_CLASS_RAISED; 13015 13016 /** 13017 * A CSS class used to indicate a read-only state. 13018 * 13019 * Refer to individual widget documentation for used style classes. 13020 */ 13021 enum STYLE_CLASS_READ_ONLY = "read-only"; 13022 alias GTK_STYLE_CLASS_READ_ONLY = STYLE_CLASS_READ_ONLY; 13023 13024 /** 13025 * A CSS class to indicate an area at the right of a widget. 13026 * 13027 * Refer to individual widget documentation for used style classes. 13028 */ 13029 enum STYLE_CLASS_RIGHT = "right"; 13030 alias GTK_STYLE_CLASS_RIGHT = STYLE_CLASS_RIGHT; 13031 13032 /** 13033 * A CSS class to match the rubberband selection rectangle. 13034 * 13035 * Refer to individual widget documentation for used style classes. 13036 */ 13037 enum STYLE_CLASS_RUBBERBAND = "rubberband"; 13038 alias GTK_STYLE_CLASS_RUBBERBAND = STYLE_CLASS_RUBBERBAND; 13039 13040 /** 13041 * A CSS class to match scale widgets. 13042 * 13043 * Refer to individual widget documentation for used style classes. 13044 */ 13045 enum STYLE_CLASS_SCALE = "scale"; 13046 alias GTK_STYLE_CLASS_SCALE = STYLE_CLASS_SCALE; 13047 13048 /** 13049 * A CSS class to match scale widgets with marks attached, 13050 * all the marks are above for horizontal #GtkScale. 13051 * left for vertical #GtkScale. 13052 * 13053 * Refer to individual widget documentation for used style classes. 13054 */ 13055 enum STYLE_CLASS_SCALE_HAS_MARKS_ABOVE = "scale-has-marks-above"; 13056 alias GTK_STYLE_CLASS_SCALE_HAS_MARKS_ABOVE = STYLE_CLASS_SCALE_HAS_MARKS_ABOVE; 13057 13058 /** 13059 * A CSS class to match scale widgets with marks attached, 13060 * all the marks are below for horizontal #GtkScale, 13061 * right for vertical #GtkScale. 13062 * 13063 * Refer to individual widget documentation for used style classes. 13064 */ 13065 enum STYLE_CLASS_SCALE_HAS_MARKS_BELOW = "scale-has-marks-below"; 13066 alias GTK_STYLE_CLASS_SCALE_HAS_MARKS_BELOW = STYLE_CLASS_SCALE_HAS_MARKS_BELOW; 13067 13068 /** 13069 * A CSS class to match scrollbars. 13070 * 13071 * Refer to individual widget documentation for used style classes. 13072 */ 13073 enum STYLE_CLASS_SCROLLBAR = "scrollbar"; 13074 alias GTK_STYLE_CLASS_SCROLLBAR = STYLE_CLASS_SCROLLBAR; 13075 13076 /** 13077 * A CSS class to match the junction area between an horizontal 13078 * and vertical scrollbar, when they’re both shown. 13079 * 13080 * Refer to individual widget documentation for used style classes. 13081 */ 13082 enum STYLE_CLASS_SCROLLBARS_JUNCTION = "scrollbars-junction"; 13083 alias GTK_STYLE_CLASS_SCROLLBARS_JUNCTION = STYLE_CLASS_SCROLLBARS_JUNCTION; 13084 13085 /** 13086 * A CSS class for a separator. 13087 * 13088 * Refer to individual widget documentation for used style classes. 13089 */ 13090 enum STYLE_CLASS_SEPARATOR = "separator"; 13091 alias GTK_STYLE_CLASS_SEPARATOR = STYLE_CLASS_SEPARATOR; 13092 13093 /** 13094 * A CSS class defining a sidebar, such as the left side in 13095 * a file chooser. 13096 * 13097 * Refer to individual widget documentation for used style classes. 13098 */ 13099 enum STYLE_CLASS_SIDEBAR = "sidebar"; 13100 alias GTK_STYLE_CLASS_SIDEBAR = STYLE_CLASS_SIDEBAR; 13101 13102 /** 13103 * A CSS class to match sliders. 13104 * 13105 * Refer to individual widget documentation for used style classes. 13106 */ 13107 enum STYLE_CLASS_SLIDER = "slider"; 13108 alias GTK_STYLE_CLASS_SLIDER = STYLE_CLASS_SLIDER; 13109 13110 /** 13111 * A CSS class defining an spinbutton. 13112 * 13113 * Refer to individual widget documentation for used style classes. 13114 */ 13115 enum STYLE_CLASS_SPINBUTTON = "spinbutton"; 13116 alias GTK_STYLE_CLASS_SPINBUTTON = STYLE_CLASS_SPINBUTTON; 13117 13118 /** 13119 * A CSS class to use when rendering activity as a “spinner”. 13120 * 13121 * Refer to individual widget documentation for used style classes. 13122 */ 13123 enum STYLE_CLASS_SPINNER = "spinner"; 13124 alias GTK_STYLE_CLASS_SPINNER = STYLE_CLASS_SPINNER; 13125 13126 /** 13127 * A CSS class to match statusbars. 13128 * 13129 * Refer to individual widget documentation for used style classes. 13130 */ 13131 enum STYLE_CLASS_STATUSBAR = "statusbar"; 13132 alias GTK_STYLE_CLASS_STATUSBAR = STYLE_CLASS_STATUSBAR; 13133 13134 /** 13135 * A CSS class used for the subtitle label in a titlebar in 13136 * a toplevel window. 13137 * 13138 * Refer to individual widget documentation for used style classes. 13139 */ 13140 enum STYLE_CLASS_SUBTITLE = "subtitle"; 13141 alias GTK_STYLE_CLASS_SUBTITLE = STYLE_CLASS_SUBTITLE; 13142 13143 /** 13144 * A CSS class used when an action (usually a button) is the 13145 * primary suggested action in a specific context. 13146 * 13147 * Refer to individual widget documentation for used style classes. 13148 */ 13149 enum STYLE_CLASS_SUGGESTED_ACTION = "suggested-action"; 13150 alias GTK_STYLE_CLASS_SUGGESTED_ACTION = STYLE_CLASS_SUGGESTED_ACTION; 13151 13152 /** 13153 * A CSS class used for the title label in a titlebar in 13154 * a toplevel window. 13155 * 13156 * Refer to individual widget documentation for used style classes. 13157 */ 13158 enum STYLE_CLASS_TITLE = "title"; 13159 alias GTK_STYLE_CLASS_TITLE = STYLE_CLASS_TITLE; 13160 13161 /** 13162 * A CSS class used when rendering a titlebar in a toplevel window. 13163 * 13164 * Refer to individual widget documentation for used style classes. 13165 */ 13166 enum STYLE_CLASS_TITLEBAR = "titlebar"; 13167 alias GTK_STYLE_CLASS_TITLEBAR = STYLE_CLASS_TITLEBAR; 13168 13169 /** 13170 * A CSS class to match toolbars. 13171 * 13172 * Refer to individual widget documentation for used style classes. 13173 */ 13174 enum STYLE_CLASS_TOOLBAR = "toolbar"; 13175 alias GTK_STYLE_CLASS_TOOLBAR = STYLE_CLASS_TOOLBAR; 13176 13177 /** 13178 * A CSS class to match tooltip windows. 13179 * 13180 * Refer to individual widget documentation for used style classes. 13181 */ 13182 enum STYLE_CLASS_TOOLTIP = "tooltip"; 13183 alias GTK_STYLE_CLASS_TOOLTIP = STYLE_CLASS_TOOLTIP; 13184 13185 /** 13186 * A CSS class to indicate an area at the top of a widget. 13187 * 13188 * Refer to individual widget documentation for used style classes. 13189 */ 13190 enum STYLE_CLASS_TOP = "top"; 13191 alias GTK_STYLE_CLASS_TOP = STYLE_CLASS_TOP; 13192 13193 /** 13194 * A CSS class for touch selection popups on entries 13195 * and text views. 13196 * 13197 * Refer to individual widget documentation for used style classes. 13198 */ 13199 enum STYLE_CLASS_TOUCH_SELECTION = "touch-selection"; 13200 alias GTK_STYLE_CLASS_TOUCH_SELECTION = STYLE_CLASS_TOUCH_SELECTION; 13201 13202 /** 13203 * A CSS class to match troughs, as in scrollbars and progressbars. 13204 * 13205 * Refer to individual widget documentation for used style classes. 13206 */ 13207 enum STYLE_CLASS_TROUGH = "trough"; 13208 alias GTK_STYLE_CLASS_TROUGH = STYLE_CLASS_TROUGH; 13209 13210 /** 13211 * A CSS class that is added on the visual hints that happen 13212 * where content is 'scrolled off' and can be made visible 13213 * by scrolling. 13214 * 13215 * Refer to individual widget documentation for used style classes. 13216 */ 13217 enum STYLE_CLASS_UNDERSHOOT = "undershoot"; 13218 alias GTK_STYLE_CLASS_UNDERSHOOT = STYLE_CLASS_UNDERSHOOT; 13219 13220 /** 13221 * A CSS class for vertically layered widgets. 13222 * 13223 * Refer to individual widget documentation for used style classes. 13224 */ 13225 enum STYLE_CLASS_VERTICAL = "vertical"; 13226 alias GTK_STYLE_CLASS_VERTICAL = STYLE_CLASS_VERTICAL; 13227 13228 /** 13229 * A CSS class defining a view, such as iconviews or treeviews. 13230 * 13231 * Refer to individual widget documentation for used style classes. 13232 */ 13233 enum STYLE_CLASS_VIEW = "view"; 13234 alias GTK_STYLE_CLASS_VIEW = STYLE_CLASS_VIEW; 13235 13236 /** 13237 * A CSS class for an area displaying a warning message, 13238 * such as those in infobars. 13239 * 13240 * Refer to individual widget documentation for used style classes. 13241 */ 13242 enum STYLE_CLASS_WARNING = "warning"; 13243 alias GTK_STYLE_CLASS_WARNING = STYLE_CLASS_WARNING; 13244 13245 /** 13246 * A CSS class to indicate that a UI element should be 'wide'. 13247 * Used by #GtkPaned. 13248 * 13249 * Refer to individual widget documentation for used style classes. 13250 */ 13251 enum STYLE_CLASS_WIDE = "wide"; 13252 alias GTK_STYLE_CLASS_WIDE = STYLE_CLASS_WIDE; 13253 13254 /** 13255 * A property holding the background color of rendered elements as a #GdkRGBA. 13256 */ 13257 enum STYLE_PROPERTY_BACKGROUND_COLOR = "background-color"; 13258 alias GTK_STYLE_PROPERTY_BACKGROUND_COLOR = STYLE_PROPERTY_BACKGROUND_COLOR; 13259 13260 /** 13261 * A property holding the element’s background as a #cairo_pattern_t. 13262 */ 13263 enum STYLE_PROPERTY_BACKGROUND_IMAGE = "background-image"; 13264 alias GTK_STYLE_PROPERTY_BACKGROUND_IMAGE = STYLE_PROPERTY_BACKGROUND_IMAGE; 13265 13266 /** 13267 * A property holding the element’s border color as a #GdkRGBA. 13268 */ 13269 enum STYLE_PROPERTY_BORDER_COLOR = "border-color"; 13270 alias GTK_STYLE_PROPERTY_BORDER_COLOR = STYLE_PROPERTY_BORDER_COLOR; 13271 13272 /** 13273 * A property holding the rendered element’s border radius in pixels as a #gint. 13274 */ 13275 enum STYLE_PROPERTY_BORDER_RADIUS = "border-radius"; 13276 alias GTK_STYLE_PROPERTY_BORDER_RADIUS = STYLE_PROPERTY_BORDER_RADIUS; 13277 13278 /** 13279 * A property holding the element’s border style as a #GtkBorderStyle. 13280 */ 13281 enum STYLE_PROPERTY_BORDER_STYLE = "border-style"; 13282 alias GTK_STYLE_PROPERTY_BORDER_STYLE = STYLE_PROPERTY_BORDER_STYLE; 13283 13284 /** 13285 * A property holding the rendered element’s border width in pixels as 13286 * a #GtkBorder. The border is the intermediary spacing property of the 13287 * padding/border/margin series. 13288 * 13289 * gtk_render_frame() uses this property to find out the frame line width, 13290 * so #GtkWidgets rendering frames may need to add up this padding when 13291 * requesting size 13292 */ 13293 enum STYLE_PROPERTY_BORDER_WIDTH = "border-width"; 13294 alias GTK_STYLE_PROPERTY_BORDER_WIDTH = STYLE_PROPERTY_BORDER_WIDTH; 13295 13296 /** 13297 * A property holding the foreground color of rendered elements as a #GdkRGBA. 13298 */ 13299 enum STYLE_PROPERTY_COLOR = "color"; 13300 alias GTK_STYLE_PROPERTY_COLOR = STYLE_PROPERTY_COLOR; 13301 13302 /** 13303 * A property holding the font properties used when rendering text 13304 * as a #PangoFontDescription. 13305 */ 13306 enum STYLE_PROPERTY_FONT = "font"; 13307 alias GTK_STYLE_PROPERTY_FONT = STYLE_PROPERTY_FONT; 13308 13309 /** 13310 * A property holding the rendered element’s margin as a #GtkBorder. The 13311 * margin is defined as the spacing between the border of the element 13312 * and its surrounding elements. It is external to #GtkWidget's 13313 * size allocations, and the most external spacing property of the 13314 * padding/border/margin series. 13315 */ 13316 enum STYLE_PROPERTY_MARGIN = "margin"; 13317 alias GTK_STYLE_PROPERTY_MARGIN = STYLE_PROPERTY_MARGIN; 13318 13319 /** 13320 * A property holding the rendered element’s padding as a #GtkBorder. The 13321 * padding is defined as the spacing between the inner part of the element border 13322 * and its child. It’s the innermost spacing property of the padding/border/margin 13323 * series. 13324 */ 13325 enum STYLE_PROPERTY_PADDING = "padding"; 13326 alias GTK_STYLE_PROPERTY_PADDING = STYLE_PROPERTY_PADDING; 13327 13328 /** 13329 * A priority that can be used when adding a #GtkStyleProvider 13330 * for application-specific style information. 13331 */ 13332 enum STYLE_PROVIDER_PRIORITY_APPLICATION = 600; 13333 alias GTK_STYLE_PROVIDER_PRIORITY_APPLICATION = STYLE_PROVIDER_PRIORITY_APPLICATION; 13334 13335 /** 13336 * The priority used for default style information 13337 * that is used in the absence of themes. 13338 * 13339 * Note that this is not very useful for providing default 13340 * styling for custom style classes - themes are likely to 13341 * override styling provided at this priority with 13342 * catch-all `* {...}` rules. 13343 */ 13344 enum STYLE_PROVIDER_PRIORITY_FALLBACK = 1; 13345 alias GTK_STYLE_PROVIDER_PRIORITY_FALLBACK = STYLE_PROVIDER_PRIORITY_FALLBACK; 13346 13347 /** 13348 * The priority used for style information provided 13349 * via #GtkSettings. 13350 * 13351 * This priority is higher than #GTK_STYLE_PROVIDER_PRIORITY_THEME 13352 * to let settings override themes. 13353 */ 13354 enum STYLE_PROVIDER_PRIORITY_SETTINGS = 400; 13355 alias GTK_STYLE_PROVIDER_PRIORITY_SETTINGS = STYLE_PROVIDER_PRIORITY_SETTINGS; 13356 13357 /** 13358 * The priority used for style information provided 13359 * by themes. 13360 */ 13361 enum STYLE_PROVIDER_PRIORITY_THEME = 200; 13362 alias GTK_STYLE_PROVIDER_PRIORITY_THEME = STYLE_PROVIDER_PRIORITY_THEME; 13363 13364 /** 13365 * The priority used for the style information from 13366 * `~/.gtk-3.0.css`. 13367 * 13368 * You should not use priorities higher than this, to 13369 * give the user the last word. 13370 */ 13371 enum STYLE_PROVIDER_PRIORITY_USER = 800; 13372 alias GTK_STYLE_PROVIDER_PRIORITY_USER = STYLE_PROVIDER_PRIORITY_USER; 13373 13374 /** 13375 * A widget region name to define a treeview column. 13376 * 13377 * Deprecated: Don't use regions. 13378 */ 13379 enum STYLE_REGION_COLUMN = "column"; 13380 alias GTK_STYLE_REGION_COLUMN = STYLE_REGION_COLUMN; 13381 13382 /** 13383 * A widget region name to define a treeview column header. 13384 * 13385 * Deprecated: Don't use regions. 13386 */ 13387 enum STYLE_REGION_COLUMN_HEADER = "column-header"; 13388 alias GTK_STYLE_REGION_COLUMN_HEADER = STYLE_REGION_COLUMN_HEADER; 13389 13390 /** 13391 * A widget region name to define a treeview row. 13392 * 13393 * Deprecated: Don't use regions. 13394 */ 13395 enum STYLE_REGION_ROW = "row"; 13396 alias GTK_STYLE_REGION_ROW = STYLE_REGION_ROW; 13397 13398 /** 13399 * A widget region name to define a notebook tab. 13400 * 13401 * Deprecated: Don't use regions. 13402 */ 13403 enum STYLE_REGION_TAB = "tab"; 13404 alias GTK_STYLE_REGION_TAB = STYLE_REGION_TAB; 13405 13406 /** 13407 * The priority at which the text view validates onscreen lines 13408 * in an idle job in the background. 13409 */ 13410 enum TEXT_VIEW_PRIORITY_VALIDATE = 5; 13411 alias GTK_TEXT_VIEW_PRIORITY_VALIDATE = TEXT_VIEW_PRIORITY_VALIDATE; 13412 13413 /** 13414 * The GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID can be used to make a 13415 * #GtkTreeSortable use the default sort function. 13416 * 13417 * See also gtk_tree_sortable_set_sort_column_id() 13418 */ 13419 enum TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID = -1; 13420 alias GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID = TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID; 13421 13422 /** 13423 * The GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID can be used to make a 13424 * #GtkTreeSortable use no sorting. 13425 * 13426 * See also gtk_tree_sortable_set_sort_column_id() 13427 */ 13428 enum TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID = -2; 13429 alias GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID = TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID; 13430 13431 /** 13432 * StockIds 13433 */ 13434 public enum StockID 13435 { 13436 /** 13437 * The “About” item. 13438 * ![](help-about.png) 13439 * 13440 * Deprecated: Use named icon "help-about" or the label "_About". 13441 */ 13442 ABOUT = "gtk-about", 13443 /** 13444 * The “Add” item and icon. 13445 * 13446 * Deprecated: Use named icon "list-add" or the label "_Add". 13447 */ 13448 ADD = "gtk-add", 13449 /** 13450 * The “Apply” item and icon. 13451 * 13452 * Deprecated: Do not use an icon. Use label "_Apply". 13453 */ 13454 APPLY = "gtk-apply", 13455 /** 13456 * The “Bold” item and icon. 13457 * 13458 * Deprecated: Use named icon "format-text-bold". 13459 */ 13460 BOLD = "gtk-bold", 13461 /** 13462 * The “Cancel” item and icon. 13463 * 13464 * Deprecated: Do not use an icon. Use label "_Cancel". 13465 */ 13466 CANCEL = "gtk-cancel", 13467 /** 13468 * The “Caps Lock Warning” icon. 13469 * 13470 * Deprecated: Use named icon "dialog-warning-symbolic". 13471 */ 13472 CAPS_LOCK_WARNING = "gtk-caps-lock-warning", 13473 /** 13474 * The “CD-Rom” item and icon. 13475 * 13476 * Deprecated: Use named icon "media-optical". 13477 */ 13478 CDROM = "gtk-cdrom", 13479 /** 13480 * The “Clear” item and icon. 13481 * 13482 * Deprecated: Use named icon "edit-clear". 13483 */ 13484 CLEAR = "gtk-clear", 13485 /** 13486 * The “Close” item and icon. 13487 * 13488 * Deprecated: Use named icon "window-close" or the label "_Close". 13489 */ 13490 CLOSE = "gtk-close", 13491 /** 13492 * The “Color Picker” item and icon. 13493 */ 13494 COLOR_PICKER = "gtk-color-picker", 13495 /** 13496 * The “Connect” icon. 13497 */ 13498 CONNECT = "gtk-connect", 13499 /** 13500 * The “Convert” item and icon. 13501 */ 13502 CONVERT = "gtk-convert", 13503 /** 13504 * The “Copy” item and icon. 13505 * 13506 * Deprecated: Use the named icon "edit-copy" or the label "_Copy". 13507 */ 13508 COPY = "gtk-copy", 13509 /** 13510 * The “Cut” item and icon. 13511 * 13512 * Deprecated: Use the named icon "edit-cut" or the label "Cu_t". 13513 */ 13514 CUT = "gtk-cut", 13515 /** 13516 * The “Delete” item and icon. 13517 * 13518 * Deprecated: Use the named icon "edit-delete" or the label "_Delete". 13519 */ 13520 DELETE = "gtk-delete", 13521 /** 13522 * The “Authentication” item and icon. 13523 * 13524 * Deprecated: Use named icon "dialog-password". 13525 */ 13526 DIALOG_AUTHENTICATION = "gtk-dialog-authentication", 13527 /** 13528 * The “Error” item and icon. 13529 * 13530 * Deprecated: Use named icon "dialog-error". 13531 */ 13532 DIALOG_ERROR = "gtk-dialog-error", 13533 /** 13534 * The “Information” item and icon. 13535 * 13536 * Deprecated: Use named icon "dialog-information". 13537 */ 13538 DIALOG_INFO = "gtk-dialog-info", 13539 /** 13540 * The “Question” item and icon. 13541 * 13542 * Deprecated: Use named icon "dialog-question". 13543 */ 13544 DIALOG_QUESTION = "gtk-dialog-question", 13545 /** 13546 * The “Warning” item and icon. 13547 * 13548 * Deprecated: Use named icon "dialog-warning". 13549 */ 13550 DIALOG_WARNING = "gtk-dialog-warning", 13551 /** 13552 * The “Directory” icon. 13553 * 13554 * Deprecated: Use named icon "folder". 13555 */ 13556 DIRECTORY = "gtk-directory", 13557 /** 13558 * The “Discard” item. 13559 */ 13560 DISCARD = "gtk-discard", 13561 /** 13562 * The “Disconnect” icon. 13563 */ 13564 DISCONNECT = "gtk-disconnect", 13565 /** 13566 * The “Drag-And-Drop” icon. 13567 */ 13568 DND = "gtk-dnd", 13569 /** 13570 * The “Drag-And-Drop multiple” icon. 13571 */ 13572 DND_MULTIPLE = "gtk-dnd-multiple", 13573 /** 13574 * The “Edit” item and icon. 13575 */ 13576 EDIT = "gtk-edit", 13577 /** 13578 * The “Execute” item and icon. 13579 * 13580 * Deprecated: Use named icon "system-run". 13581 */ 13582 EXECUTE = "gtk-execute", 13583 /** 13584 * The “File” item and icon. 13585 * 13586 * Since 3.0, this item has a label, before it only had an icon. 13587 * 13588 * Deprecated: Use named icon "text-x-generic". 13589 */ 13590 FILE = "gtk-file", 13591 /** 13592 * The “Find” item and icon. 13593 * 13594 * Deprecated: Use named icon "edit-find". 13595 */ 13596 FIND = "gtk-find", 13597 /** 13598 * The “Find and Replace” item and icon. 13599 * 13600 * Deprecated: Use named icon "edit-find-replace". 13601 */ 13602 FIND_AND_REPLACE = "gtk-find-and-replace", 13603 /** 13604 * The “Floppy” item and icon. 13605 */ 13606 FLOPPY = "gtk-floppy", 13607 /** 13608 * The “Fullscreen” item and icon. 13609 * 13610 * Deprecated: Use named icon "view-fullscreen". 13611 */ 13612 FULLSCREEN = "gtk-fullscreen", 13613 /** 13614 * The “Bottom” item and icon. 13615 * 13616 * Deprecated: Use named icon "go-bottom". 13617 */ 13618 GOTO_BOTTOM = "gtk-goto-bottom", 13619 /** 13620 * The “First” item and icon. The icon has an RTL variant. 13621 * 13622 * Deprecated: Use named icon "go-first". 13623 */ 13624 GOTO_FIRST = "gtk-goto-first", 13625 /** 13626 * The “Last” item and icon. The icon has an RTL variant. 13627 * 13628 * Deprecated: Use named icon "go-last". 13629 */ 13630 GOTO_LAST = "gtk-goto-last", 13631 /** 13632 * The “Top” item and icon. 13633 * 13634 * Deprecated: Use named icon "go-top". 13635 */ 13636 GOTO_TOP = "gtk-goto-top", 13637 /** 13638 * The “Back” item and icon. The icon has an RTL variant. 13639 * 13640 * Deprecated: Use named icon "go-previous". 13641 */ 13642 GO_BACK = "gtk-go-back", 13643 /** 13644 * The “Down” item and icon. 13645 * 13646 * Deprecated: Use named icon "go-down". 13647 */ 13648 GO_DOWN = "gtk-go-down", 13649 /** 13650 * The “Forward” item and icon. The icon has an RTL variant. 13651 * 13652 * Deprecated: Use named icon "go-next". 13653 */ 13654 GO_FORWARD = "gtk-go-forward", 13655 /** 13656 * The “Up” item and icon. 13657 * 13658 * Deprecated: Use named icon "go-up". 13659 */ 13660 GO_UP = "gtk-go-up", 13661 /** 13662 * The “Harddisk” item and icon. 13663 * 13664 * Deprecated: Use named icon "drive-harddisk". 13665 */ 13666 HARDDISK = "gtk-harddisk", 13667 /** 13668 * The “Help” item and icon. 13669 * 13670 * Deprecated: Use named icon "help-browser". 13671 */ 13672 HELP = "gtk-help", 13673 /** 13674 * The “Home” item and icon. 13675 * 13676 * Deprecated: Use named icon "go-home". 13677 */ 13678 HOME = "gtk-home", 13679 /** 13680 * The “Indent” item and icon. The icon has an RTL variant. 13681 * 13682 * Deprecated: Use named icon "format-indent-more". 13683 */ 13684 INDENT = "gtk-indent", 13685 /** 13686 * The “Index” item and icon. 13687 */ 13688 INDEX = "gtk-index", 13689 /** 13690 * The “Info” item and icon. 13691 * 13692 * Deprecated: Use named icon "dialog-information". 13693 */ 13694 INFO = "gtk-info", 13695 /** 13696 * The “Italic” item and icon. 13697 * 13698 * Deprecated: Use named icon "format-text-italic". 13699 */ 13700 ITALIC = "gtk-italic", 13701 /** 13702 * The “Jump to” item and icon. The icon has an RTL variant. 13703 * 13704 * Deprecated: Use named icon "go-jump". 13705 */ 13706 JUMP_TO = "gtk-jump-to", 13707 /** 13708 * The “Center” item and icon. 13709 * 13710 * Deprecated: Use named icon "format-justify-center". 13711 */ 13712 JUSTIFY_CENTER = "gtk-justify-center", 13713 /** 13714 * The “Fill” item and icon. 13715 * 13716 * Deprecated: Use named icon "format-justify-fill". 13717 */ 13718 JUSTIFY_FILL = "gtk-justify-fill", 13719 /** 13720 * The “Left” item and icon. 13721 * 13722 * Deprecated: Use named icon "format-justify-left". 13723 */ 13724 JUSTIFY_LEFT = "gtk-justify-left", 13725 /** 13726 * The “Right” item and icon. 13727 * 13728 * Deprecated: Use named icon "format-justify-right". 13729 */ 13730 JUSTIFY_RIGHT = "gtk-justify-right", 13731 /** 13732 * The “Leave Fullscreen” item and icon. 13733 * 13734 * Deprecated: Use named icon "view-restore". 13735 */ 13736 LEAVE_FULLSCREEN = "gtk-leave-fullscreen", 13737 /** 13738 * The “Media Forward” item and icon. The icon has an RTL variant. 13739 * 13740 * Deprecated: Use named icon "media-seek-forward" or the label "_Forward". 13741 */ 13742 MEDIA_FORWARD = "gtk-media-forward", 13743 /** 13744 * The “Media Next” item and icon. The icon has an RTL variant. 13745 * 13746 * Deprecated: Use named icon "media-skip-forward" or the label "_Next". 13747 */ 13748 MEDIA_NEXT = "gtk-media-next", 13749 /** 13750 * The “Media Pause” item and icon. 13751 * 13752 * Deprecated: Use named icon "media-playback-pause" or the label "P_ause". 13753 */ 13754 MEDIA_PAUSE = "gtk-media-pause", 13755 /** 13756 * The “Media Play” item and icon. The icon has an RTL variant. 13757 * 13758 * Deprecated: Use named icon "media-playback-start" or the label "_Play". 13759 */ 13760 MEDIA_PLAY = "gtk-media-play", 13761 /** 13762 * The “Media Previous” item and icon. The icon has an RTL variant. 13763 * 13764 * Deprecated: Use named icon "media-skip-backward" or the label "Pre_vious". 13765 */ 13766 MEDIA_PREVIOUS = "gtk-media-previous", 13767 /** 13768 * The “Media Record” item and icon. 13769 * 13770 * Deprecated: Use named icon "media-record" or the label "_Record". 13771 */ 13772 MEDIA_RECORD = "gtk-media-record", 13773 /** 13774 * The “Media Rewind” item and icon. The icon has an RTL variant. 13775 * 13776 * Deprecated: Use named icon "media-seek-backward" or the label "R_ewind". 13777 */ 13778 MEDIA_REWIND = "gtk-media-rewind", 13779 /** 13780 * The “Media Stop” item and icon. 13781 * 13782 * Deprecated: Use named icon "media-playback-stop" or the label "_Stop". 13783 */ 13784 MEDIA_STOP = "gtk-media-stop", 13785 /** 13786 * The “Missing image” icon. 13787 * 13788 * Deprecated: Use named icon "image-missing". 13789 */ 13790 MISSING_IMAGE = "gtk-missing-image", 13791 /** 13792 * The “Network” item and icon. 13793 * 13794 * Deprecated: Use named icon "network-workgroup". 13795 */ 13796 NETWORK = "gtk-network", 13797 /** 13798 * The “New” item and icon. 13799 * 13800 * Deprecated: Use named icon "document-new" or the label "_New". 13801 */ 13802 NEW = "gtk-new", 13803 /** 13804 * The “No” item and icon. 13805 */ 13806 NO = "gtk-no", 13807 /** 13808 * The “OK” item and icon. 13809 * 13810 * Deprecated: Do not use an icon. Use label "_OK". 13811 */ 13812 OK = "gtk-ok", 13813 /** 13814 * The “Open” item and icon. 13815 * 13816 * Deprecated: Use named icon "document-open" or the label "_Open". 13817 */ 13818 OPEN = "gtk-open", 13819 /** 13820 * The “Landscape Orientation” item and icon. 13821 */ 13822 ORIENTATION_LANDSCAPE = "gtk-orientation-landscape", 13823 /** 13824 * The “Portrait Orientation” item and icon. 13825 */ 13826 ORIENTATION_PORTRAIT = "gtk-orientation-portrait", 13827 /** 13828 * The “Reverse Landscape Orientation” item and icon. 13829 */ 13830 ORIENTATION_REVERSE_LANDSCAPE = "gtk-orientation-reverse-landscape", 13831 /** 13832 * The “Reverse Portrait Orientation” item and icon. 13833 */ 13834 ORIENTATION_REVERSE_PORTRAIT = "gtk-orientation-reverse-portrait", 13835 /** 13836 * The “Page Setup” item and icon. 13837 * 13838 * Deprecated: Use named icon "document-page-setup" or the label "Page Set_up". 13839 */ 13840 PAGE_SETUP = "gtk-page-setup", 13841 /** 13842 * The “Paste” item and icon. 13843 * 13844 * Deprecated: Use named icon "edit-paste" or the label "_Paste". 13845 */ 13846 PASTE = "gtk-paste", 13847 /** 13848 * The “Preferences” item and icon. 13849 * 13850 * Deprecated: Use named icon "preferences-system" or the label "_Preferences". 13851 */ 13852 PREFERENCES = "gtk-preferences", 13853 /** 13854 * The “Print” item and icon. 13855 * 13856 * Deprecated: Use named icon "document-print" or the label "_Print". 13857 */ 13858 PRINT = "gtk-print", 13859 /** 13860 * The “Print Error” icon. 13861 * 13862 * Deprecated: Use named icon "printer-error". 13863 */ 13864 PRINT_ERROR = "gtk-print-error", 13865 /** 13866 * The “Print Paused” icon. 13867 */ 13868 PRINT_PAUSED = "gtk-print-paused", 13869 /** 13870 * The “Print Preview” item and icon. 13871 * 13872 * Deprecated: Use label "Pre_view". 13873 */ 13874 PRINT_PREVIEW = "gtk-print-preview", 13875 /** 13876 * The “Print Report” icon. 13877 */ 13878 PRINT_REPORT = "gtk-print-report", 13879 /** 13880 * The “Print Warning” icon. 13881 */ 13882 PRINT_WARNING = "gtk-print-warning", 13883 /** 13884 * The “Properties” item and icon. 13885 * 13886 * Deprecated: Use named icon "document-properties" or the label "_Properties". 13887 */ 13888 PROPERTIES = "gtk-properties", 13889 /** 13890 * The “Quit” item and icon. 13891 * 13892 * Deprecated: Use named icon "application-exit" or the label "_Quit". 13893 */ 13894 QUIT = "gtk-quit", 13895 /** 13896 * The “Redo” item and icon. The icon has an RTL variant. 13897 * 13898 * Deprecated: Use named icon "edit-redo" or the label "_Redo". 13899 */ 13900 REDO = "gtk-redo", 13901 /** 13902 * The “Refresh” item and icon. 13903 * 13904 * Deprecated: Use named icon "view-refresh" or the label "_Refresh". 13905 */ 13906 REFRESH = "gtk-refresh", 13907 /** 13908 * The “Remove” item and icon. 13909 * 13910 * Deprecated: Use named icon "list-remove" or the label "_Remove". 13911 */ 13912 REMOVE = "gtk-remove", 13913 /** 13914 * The “Revert” item and icon. The icon has an RTL variant. 13915 * 13916 * Deprecated: Use named icon "document-revert" or the label "_Revert". 13917 */ 13918 REVERT_TO_SAVED = "gtk-revert-to-saved", 13919 /** 13920 * The “Save” item and icon. 13921 * 13922 * Deprecated: Use named icon "document-save" or the label "_Save". 13923 */ 13924 SAVE = "gtk-save", 13925 /** 13926 * The “Save As” item and icon. 13927 * 13928 * Deprecated: Use named icon "document-save-as" or the label "Save _As". 13929 */ 13930 SAVE_AS = "gtk-save-as", 13931 /** 13932 * The “Select All” item and icon. 13933 * 13934 * Deprecated: Use named icon "edit-select-all" or the label "Select _All". 13935 */ 13936 SELECT_ALL = "gtk-select-all", 13937 /** 13938 * The “Color” item and icon. 13939 */ 13940 SELECT_COLOR = "gtk-select-color", 13941 /** 13942 * The “Font” item and icon. 13943 */ 13944 SELECT_FONT = "gtk-select-font", 13945 /** 13946 * The “Ascending” item and icon. 13947 * 13948 * Deprecated: Use named icon "view-sort-ascending". 13949 */ 13950 SORT_ASCENDING = "gtk-sort-ascending", 13951 /** 13952 * The “Descending” item and icon. 13953 * 13954 * Deprecated: Use named icon "view-sort-descending". 13955 */ 13956 SORT_DESCENDING = "gtk-sort-descending", 13957 /** 13958 * The “Spell Check” item and icon. 13959 * 13960 * Deprecated: Use named icon "tools-check-spelling". 13961 */ 13962 SPELL_CHECK = "gtk-spell-check", 13963 /** 13964 * The “Stop” item and icon. 13965 * 13966 * Deprecated: Use named icon "process-stop" or the label "_Stop". 13967 */ 13968 STOP = "gtk-stop", 13969 /** 13970 * The “Strikethrough” item and icon. 13971 * 13972 * Deprecated: Use named icon "format-text-strikethrough" or the label "_Strikethrough". 13973 */ 13974 STRIKETHROUGH = "gtk-strikethrough", 13975 /** 13976 * The “Undelete” item and icon. The icon has an RTL variant. 13977 */ 13978 UNDELETE = "gtk-undelete", 13979 /** 13980 * The “Underline” item and icon. 13981 * 13982 * Deprecated: Use named icon "format-text-underline" or the label "_Underline". 13983 */ 13984 UNDERLINE = "gtk-underline", 13985 /** 13986 * The “Undo” item and icon. The icon has an RTL variant. 13987 * 13988 * Deprecated: Use named icon "edit-undo" or the label "_Undo". 13989 */ 13990 UNDO = "gtk-undo", 13991 /** 13992 * The “Unindent” item and icon. The icon has an RTL variant. 13993 * 13994 * Deprecated: Use named icon "format-indent-less". 13995 */ 13996 UNINDENT = "gtk-unindent", 13997 /** 13998 * The “Yes” item and icon. 13999 */ 14000 YES = "gtk-yes", 14001 /** 14002 * The “Zoom 100%” item and icon. 14003 * 14004 * Deprecated: Use named icon "zoom-original" or the label "_Normal Size". 14005 */ 14006 ZOOM_100 = "gtk-zoom-100", 14007 /** 14008 * The “Zoom to Fit” item and icon. 14009 * 14010 * Deprecated: Use named icon "zoom-fit-best" or the label "Best _Fit". 14011 */ 14012 ZOOM_FIT = "gtk-zoom-fit", 14013 /** 14014 * The “Zoom In” item and icon. 14015 * 14016 * Deprecated: Use named icon "zoom-in" or the label "Zoom _In". 14017 */ 14018 ZOOM_IN = "gtk-zoom-in", 14019 /** 14020 * The “Zoom Out” item and icon. 14021 * 14022 * Deprecated: Use named icon "zoom-out" or the label "Zoom _Out". 14023 */ 14024 ZOOM_OUT = "gtk-zoom-out", 14025 }