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