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