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