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