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