1 // Generated by gmmproc 2.60.0 -- DO NOT MODIFY! 2 #ifndef _GTKMM_ENUMS_H 3 #define _GTKMM_ENUMS_H 4 5 6 #include <glibmm/ustring.h> 7 #include <sigc++/sigc++.h> 8 9 /* 10 * Copyright (C) 2002 The gtkmm Development Team 11 * 12 * This library is free software; you can redistribute it and/or 13 * modify it under the terms of the GNU Lesser General Public 14 * License as published by the Free Software Foundation; either 15 * version 2.1 of the License, or (at your option) any later version. 16 * 17 * This library is distributed in the hope that it will be useful, 18 * but WITHOUT ANY WARRANTY; without even the implied warranty of 19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 20 * Lesser General Public License for more details. 21 * 22 * You should have received a copy of the GNU Lesser General Public 23 * License along with this library; if not, write to the Free Software 24 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 25 */ 26 27 #include <glibmm/value.h> 28 #include <gtk/gtk.h> 29 30 31 namespace Gtk 32 { 33 34 35 /** @addtogroup gtkmmEnums gtkmm Enums and Flags */ 36 37 /** 38 * @var AccelFlags ACCEL_VISIBLE 39 * Accelerator is visible. 40 * 41 * @var AccelFlags ACCEL_LOCKED 42 * Accelerator not removable. 43 * 44 * @var AccelFlags ACCEL_MASK 45 * Mask. 46 * 47 * @enum AccelFlags 48 * 49 * Accelerator flags used with Gtk::AccelGroup::connect(). 50 * 51 * @ingroup gtkmmEnums 52 * @par Bitwise operators: 53 * <tt>%AccelFlags operator|(AccelFlags, AccelFlags)</tt><br> 54 * <tt>%AccelFlags operator&(AccelFlags, AccelFlags)</tt><br> 55 * <tt>%AccelFlags operator^(AccelFlags, AccelFlags)</tt><br> 56 * <tt>%AccelFlags operator~(AccelFlags)</tt><br> 57 * <tt>%AccelFlags& operator|=(AccelFlags&, AccelFlags)</tt><br> 58 * <tt>%AccelFlags& operator&=(AccelFlags&, AccelFlags)</tt><br> 59 * <tt>%AccelFlags& operator^=(AccelFlags&, AccelFlags)</tt><br> 60 */ 61 enum AccelFlags 62 { 63 ACCEL_VISIBLE = 1 << 0, 64 ACCEL_LOCKED = 1 << 1, 65 ACCEL_MASK = 0x07 66 }; 67 68 /** @ingroup gtkmmEnums */ 69 inline AccelFlags operator|(AccelFlags lhs, AccelFlags rhs) 70 { return static_cast<AccelFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); } 71 72 /** @ingroup gtkmmEnums */ 73 inline AccelFlags operator&(AccelFlags lhs, AccelFlags rhs) 74 { return static_cast<AccelFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); } 75 76 /** @ingroup gtkmmEnums */ 77 inline AccelFlags operator^(AccelFlags lhs, AccelFlags rhs) 78 { return static_cast<AccelFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); } 79 80 /** @ingroup gtkmmEnums */ 81 inline AccelFlags operator~(AccelFlags flags) 82 { return static_cast<AccelFlags>(~static_cast<unsigned>(flags)); } 83 84 /** @ingroup gtkmmEnums */ 85 inline AccelFlags& operator|=(AccelFlags& lhs, AccelFlags rhs) 86 { return (lhs = static_cast<AccelFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); } 87 88 /** @ingroup gtkmmEnums */ 89 inline AccelFlags& operator&=(AccelFlags& lhs, AccelFlags rhs) 90 { return (lhs = static_cast<AccelFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); } 91 92 /** @ingroup gtkmmEnums */ 93 inline AccelFlags& operator^=(AccelFlags& lhs, AccelFlags rhs) 94 { return (lhs = static_cast<AccelFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); } 95 96 } // namespace Gtk 97 98 #ifndef DOXYGEN_SHOULD_SKIP_THIS 99 namespace Glib 100 { 101 102 template <> 103 class Value<Gtk::AccelFlags> : public Glib::Value_Flags<Gtk::AccelFlags> 104 { 105 public: 106 static GType value_type() G_GNUC_CONST; 107 }; 108 109 } // namespace Glib 110 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 111 112 namespace Gtk 113 { 114 115 /** 116 * @var Align ALIGN_FILL 117 * Stretch to fill all space if possible, center if 118 * no meaningful way to stretch. 119 * 120 * @var Align ALIGN_START 121 * Snap to left or top side, leaving space on right 122 * or bottom. 123 * 124 * @var Align ALIGN_END 125 * Snap to right or bottom side, leaving space on left 126 * or top. 127 * 128 * @var Align ALIGN_CENTER 129 * Center natural width of widget inside the 130 * allocation. 131 * 132 * @var Align ALIGN_BASELINE 133 * Align the widget according to the baseline. @newin{3,10} 134 * 135 * @enum Align 136 * 137 * Controls how a widget deals with extra space in a single (x or y) 138 * dimension. 139 * 140 * Alignment only matters if the widget receives a “too large” allocation, 141 * for example if you packed the widget with the Gtk::Widget::property_expand() 142 * flag inside a Gtk::Box, then the widget might get extra space. If 143 * you have for example a 16x16 icon inside a 32x32 space, the icon 144 * could be scaled and stretched, it could be centered, or it could be 145 * positioned to one side of the space. 146 * 147 * Note that in horizontal context @a GTK_ALIGN_START and @a GTK_ALIGN_END 148 * are interpreted relative to text direction. 149 * 150 * GTK_ALIGN_BASELINE support for it is optional for containers and widgets, and 151 * it is only supported for vertical alignment. When its not supported by 152 * a child or a container it is treated as @a GTK_ALIGN_FILL. 153 * 154 * @ingroup gtkmmEnums 155 */ 156 enum Align 157 { 158 ALIGN_FILL, 159 ALIGN_START, 160 ALIGN_END, 161 ALIGN_CENTER, 162 ALIGN_BASELINE 163 }; 164 165 } // namespace Gtk 166 167 #ifndef DOXYGEN_SHOULD_SKIP_THIS 168 namespace Glib 169 { 170 171 template <> 172 class Value<Gtk::Align> : public Glib::Value_Enum<Gtk::Align> 173 { 174 public: 175 static GType value_type() G_GNUC_CONST; 176 }; 177 178 } // namespace Glib 179 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 180 181 namespace Gtk 182 { 183 184 /** 185 * @var ArrowType ARROW_UP 186 * Represents an upward pointing arrow. 187 * 188 * @var ArrowType ARROW_DOWN 189 * Represents a downward pointing arrow. 190 * 191 * @var ArrowType ARROW_LEFT 192 * Represents a left pointing arrow. 193 * 194 * @var ArrowType ARROW_RIGHT 195 * Represents a right pointing arrow. 196 * 197 * @var ArrowType ARROW_NONE 198 * No arrow. @newin{2,10} 199 * 200 * @enum ArrowType 201 * 202 * Used to indicate the direction in which an arrow should point. 203 * 204 * @ingroup gtkmmEnums 205 */ 206 enum ArrowType 207 { 208 ARROW_UP, 209 ARROW_DOWN, 210 ARROW_LEFT, 211 ARROW_RIGHT, 212 ARROW_NONE 213 }; 214 215 } // namespace Gtk 216 217 #ifndef DOXYGEN_SHOULD_SKIP_THIS 218 namespace Glib 219 { 220 221 template <> 222 class Value<Gtk::ArrowType> : public Glib::Value_Enum<Gtk::ArrowType> 223 { 224 public: 225 static GType value_type() G_GNUC_CONST; 226 }; 227 228 } // namespace Glib 229 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 230 231 namespace Gtk 232 { 233 234 /** 235 * @var AttachOptions EXPAND 236 * The widget should expand to take up any extra space in its 237 * container that has been allocated. 238 * 239 * @var AttachOptions SHRINK 240 * The widget should shrink as and when possible. 241 * 242 * @var AttachOptions FILL 243 * The widget should fill the space allocated to it. 244 * 245 * @enum AttachOptions 246 * 247 * Denotes the expansion properties that a widget will have when it (or its 248 * parent) is resized. 249 * 250 * @ingroup gtkmmEnums 251 * @par Bitwise operators: 252 * <tt>%AttachOptions operator|(AttachOptions, AttachOptions)</tt><br> 253 * <tt>%AttachOptions operator&(AttachOptions, AttachOptions)</tt><br> 254 * <tt>%AttachOptions operator^(AttachOptions, AttachOptions)</tt><br> 255 * <tt>%AttachOptions operator~(AttachOptions)</tt><br> 256 * <tt>%AttachOptions& operator|=(AttachOptions&, AttachOptions)</tt><br> 257 * <tt>%AttachOptions& operator&=(AttachOptions&, AttachOptions)</tt><br> 258 * <tt>%AttachOptions& operator^=(AttachOptions&, AttachOptions)</tt><br> 259 */ 260 enum AttachOptions 261 { 262 EXPAND = 1 << 0, 263 SHRINK = 1 << 1, 264 FILL = 1 << 2 265 }; 266 267 /** @ingroup gtkmmEnums */ 268 inline AttachOptions operator|(AttachOptions lhs, AttachOptions rhs) 269 { return static_cast<AttachOptions>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); } 270 271 /** @ingroup gtkmmEnums */ 272 inline AttachOptions operator&(AttachOptions lhs, AttachOptions rhs) 273 { return static_cast<AttachOptions>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); } 274 275 /** @ingroup gtkmmEnums */ 276 inline AttachOptions operator^(AttachOptions lhs, AttachOptions rhs) 277 { return static_cast<AttachOptions>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); } 278 279 /** @ingroup gtkmmEnums */ 280 inline AttachOptions operator~(AttachOptions flags) 281 { return static_cast<AttachOptions>(~static_cast<unsigned>(flags)); } 282 283 /** @ingroup gtkmmEnums */ 284 inline AttachOptions& operator|=(AttachOptions& lhs, AttachOptions rhs) 285 { return (lhs = static_cast<AttachOptions>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); } 286 287 /** @ingroup gtkmmEnums */ 288 inline AttachOptions& operator&=(AttachOptions& lhs, AttachOptions rhs) 289 { return (lhs = static_cast<AttachOptions>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); } 290 291 /** @ingroup gtkmmEnums */ 292 inline AttachOptions& operator^=(AttachOptions& lhs, AttachOptions rhs) 293 { return (lhs = static_cast<AttachOptions>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); } 294 295 } // namespace Gtk 296 297 #ifndef DOXYGEN_SHOULD_SKIP_THIS 298 namespace Glib 299 { 300 301 template <> 302 class Value<Gtk::AttachOptions> : public Glib::Value_Flags<Gtk::AttachOptions> 303 { 304 public: 305 static GType value_type() G_GNUC_CONST; 306 }; 307 308 } // namespace Glib 309 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 310 311 namespace Gtk 312 { 313 314 /** 315 * @var ButtonBoxStyle BUTTONBOX_SPREAD 316 * Buttons are evenly spread across the box. 317 * 318 * @var ButtonBoxStyle BUTTONBOX_EDGE 319 * Buttons are placed at the edges of the box. 320 * 321 * @var ButtonBoxStyle BUTTONBOX_START 322 * Buttons are grouped towards the start of the box, 323 * (on the left for a HBox, or the top for a VBox). 324 * 325 * @var ButtonBoxStyle BUTTONBOX_END 326 * Buttons are grouped towards the end of the box, 327 * (on the right for a HBox, or the bottom for a VBox). 328 * 329 * @var ButtonBoxStyle BUTTONBOX_CENTER 330 * Buttons are centered in the box. @newin{2,12} 331 * 332 * @var ButtonBoxStyle BUTTONBOX_EXPAND 333 * Buttons expand to fill the box. This entails giving 334 * buttons a "linked" appearance, making button sizes homogeneous, and 335 * setting spacing to 0 (same as calling Gtk::Box::set_homogeneous() and 336 * Gtk::Box::set_spacing() manually). @newin{3,12} 337 * 338 * @enum ButtonBoxStyle 339 * 340 * Used to dictate the style that a Gtk::ButtonBox uses to layout the buttons it 341 * contains. 342 * 343 * @ingroup gtkmmEnums 344 */ 345 enum ButtonBoxStyle 346 { 347 BUTTONBOX_SPREAD = 1, 348 BUTTONBOX_EDGE, 349 BUTTONBOX_START, 350 BUTTONBOX_END, 351 BUTTONBOX_CENTER, 352 BUTTONBOX_EXPAND 353 }; 354 355 } // namespace Gtk 356 357 #ifndef DOXYGEN_SHOULD_SKIP_THIS 358 namespace Glib 359 { 360 361 template <> 362 class Value<Gtk::ButtonBoxStyle> : public Glib::Value_Enum<Gtk::ButtonBoxStyle> 363 { 364 public: 365 static GType value_type() G_GNUC_CONST; 366 }; 367 368 } // namespace Glib 369 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 370 371 namespace Gtk 372 { 373 374 /** 375 * @var DeleteType DELETE_CHARS 376 * Delete characters. 377 * 378 * @var DeleteType DELETE_WORD_ENDS 379 * Delete only the portion of the word to the 380 * left/right of cursor if we’re in the middle of a word. 381 * 382 * @var DeleteType DELETE_WORDS 383 * Delete words. 384 * 385 * @var DeleteType DELETE_DISPLAY_LINES 386 * Delete display-lines. Display-lines 387 * refers to the visible lines, with respect to to the current line 388 * breaks. As opposed to paragraphs, which are defined by line 389 * breaks in the input. 390 * 391 * @var DeleteType DELETE_DISPLAY_LINE_ENDS 392 * Delete only the portion of the 393 * display-line to the left/right of cursor. 394 * 395 * @var DeleteType DELETE_PARAGRAPH_ENDS 396 * Delete to the end of the 397 * paragraph. Like C-k in Emacs (or its reverse). 398 * 399 * @var DeleteType DELETE_PARAGRAPHS 400 * Delete entire line. Like C-k in pico. 401 * 402 * @var DeleteType DELETE_WHITESPACE 403 * Delete only whitespace. Like M-\\ in Emacs. 404 * 405 * @enum DeleteType 406 * 407 * See also: Gtk::Entry::signal_delete_from_cursor(). 408 * 409 * @ingroup gtkmmEnums 410 */ 411 enum DeleteType 412 { 413 DELETE_CHARS, 414 DELETE_WORD_ENDS, 415 DELETE_WORDS, 416 DELETE_DISPLAY_LINES, 417 DELETE_DISPLAY_LINE_ENDS, 418 DELETE_PARAGRAPH_ENDS, 419 DELETE_PARAGRAPHS, 420 DELETE_WHITESPACE 421 }; 422 423 } // namespace Gtk 424 425 #ifndef DOXYGEN_SHOULD_SKIP_THIS 426 namespace Glib 427 { 428 429 template <> 430 class Value<Gtk::DeleteType> : public Glib::Value_Enum<Gtk::DeleteType> 431 { 432 public: 433 static GType value_type() G_GNUC_CONST; 434 }; 435 436 } // namespace Glib 437 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 438 439 namespace Gtk 440 { 441 442 /** 443 * @var DirectionType DIR_TAB_FORWARD 444 * Move forward. 445 * 446 * @var DirectionType DIR_TAB_BACKWARD 447 * Move backward. 448 * 449 * @var DirectionType DIR_UP 450 * Move up. 451 * 452 * @var DirectionType DIR_DOWN 453 * Move down. 454 * 455 * @var DirectionType DIR_LEFT 456 * Move left. 457 * 458 * @var DirectionType DIR_RIGHT 459 * Move right. 460 * 461 * @enum DirectionType 462 * 463 * Focus movement types. 464 * 465 * @ingroup gtkmmEnums 466 */ 467 enum DirectionType 468 { 469 DIR_TAB_FORWARD, 470 DIR_TAB_BACKWARD, 471 DIR_UP, 472 DIR_DOWN, 473 DIR_LEFT, 474 DIR_RIGHT 475 }; 476 477 } // namespace Gtk 478 479 #ifndef DOXYGEN_SHOULD_SKIP_THIS 480 namespace Glib 481 { 482 483 template <> 484 class Value<Gtk::DirectionType> : public Glib::Value_Enum<Gtk::DirectionType> 485 { 486 public: 487 static GType value_type() G_GNUC_CONST; 488 }; 489 490 } // namespace Glib 491 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 492 493 namespace Gtk 494 { 495 496 497 //TODO: let _WRAP_ENUM() take a deprecated option. 498 /** 499 * @deprecated This is not used in the gtkmm API. 500 * @var ExpanderStyle EXPANDER_COLLAPSED 501 * The style used for a collapsed subtree. 502 * 503 * @var ExpanderStyle EXPANDER_SEMI_COLLAPSED 504 * Intermediate style used during animation. 505 * 506 * @var ExpanderStyle EXPANDER_SEMI_EXPANDED 507 * Intermediate style used during animation. 508 * 509 * @var ExpanderStyle EXPANDER_EXPANDED 510 * The style used for an expanded subtree. 511 * 512 * @enum ExpanderStyle 513 * 514 * Used to specify the style of the expanders drawn by a Gtk::TreeView. 515 * 516 * @ingroup gtkmmEnums 517 */ 518 enum ExpanderStyle 519 { 520 EXPANDER_COLLAPSED, 521 EXPANDER_SEMI_COLLAPSED, 522 EXPANDER_SEMI_EXPANDED, 523 EXPANDER_EXPANDED 524 }; 525 526 } // namespace Gtk 527 528 #ifndef DOXYGEN_SHOULD_SKIP_THIS 529 namespace Glib 530 { 531 532 template <> 533 class Value<Gtk::ExpanderStyle> : public Glib::Value_Enum<Gtk::ExpanderStyle> 534 { 535 public: 536 static GType value_type() G_GNUC_CONST; 537 }; 538 539 } // namespace Glib 540 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 541 542 namespace Gtk 543 { 544 545 546 /** 547 * @var BuiltinIconSize ICON_SIZE_INVALID 548 * Invalid size. 549 * 550 * @var BuiltinIconSize ICON_SIZE_MENU 551 * Size appropriate for menus (16px). 552 * 553 * @var BuiltinIconSize ICON_SIZE_SMALL_TOOLBAR 554 * Size appropriate for small toolbars (16px). 555 * 556 * @var BuiltinIconSize ICON_SIZE_LARGE_TOOLBAR 557 * Size appropriate for large toolbars (24px). 558 * 559 * @var BuiltinIconSize ICON_SIZE_BUTTON 560 * Size appropriate for buttons (16px). 561 * 562 * @var BuiltinIconSize ICON_SIZE_DND 563 * Size appropriate for drag and drop (32px). 564 * 565 * @var BuiltinIconSize ICON_SIZE_DIALOG 566 * Size appropriate for dialogs (48px). 567 * 568 * @enum BuiltinIconSize 569 * 570 * Built-in stock icon sizes. 571 * 572 * @ingroup gtkmmEnums 573 */ 574 enum BuiltinIconSize 575 { 576 ICON_SIZE_INVALID, 577 ICON_SIZE_MENU, 578 ICON_SIZE_SMALL_TOOLBAR, 579 ICON_SIZE_LARGE_TOOLBAR, 580 ICON_SIZE_BUTTON, 581 ICON_SIZE_DND, 582 ICON_SIZE_DIALOG 583 }; 584 585 } // namespace Gtk 586 587 #ifndef DOXYGEN_SHOULD_SKIP_THIS 588 namespace Glib 589 { 590 591 template <> 592 class Value<Gtk::BuiltinIconSize> : public Glib::Value_Enum<Gtk::BuiltinIconSize> 593 { 594 public: 595 static GType value_type() G_GNUC_CONST; 596 }; 597 598 } // namespace Glib 599 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 600 601 namespace Gtk 602 { 603 604 /** 605 * @var TextDirection TEXT_DIR_NONE 606 * No direction. 607 * 608 * @var TextDirection TEXT_DIR_LTR 609 * Left to right text direction. 610 * 611 * @var TextDirection TEXT_DIR_RTL 612 * Right to left text direction. 613 * 614 * @enum TextDirection 615 * 616 * Reading directions for text. 617 * 618 * @ingroup gtkmmEnums 619 */ 620 enum TextDirection 621 { 622 TEXT_DIR_NONE, 623 TEXT_DIR_LTR, 624 TEXT_DIR_RTL 625 }; 626 627 } // namespace Gtk 628 629 #ifndef DOXYGEN_SHOULD_SKIP_THIS 630 namespace Glib 631 { 632 633 template <> 634 class Value<Gtk::TextDirection> : public Glib::Value_Enum<Gtk::TextDirection> 635 { 636 public: 637 static GType value_type() G_GNUC_CONST; 638 }; 639 640 } // namespace Glib 641 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 642 643 namespace Gtk 644 { 645 646 /** 647 * @var Justification JUSTIFY_LEFT 648 * The text is placed at the left edge of the label. 649 * 650 * @var Justification JUSTIFY_RIGHT 651 * The text is placed at the right edge of the label. 652 * 653 * @var Justification JUSTIFY_CENTER 654 * The text is placed in the center of the label. 655 * 656 * @var Justification JUSTIFY_FILL 657 * The text is placed is distributed across the label. 658 * 659 * @enum Justification 660 * 661 * Used for justifying the text inside a Gtk::Label widget. (See also 662 * Gtk::Alignment). 663 * 664 * @ingroup gtkmmEnums 665 */ 666 enum Justification 667 { 668 JUSTIFY_LEFT, 669 JUSTIFY_RIGHT, 670 JUSTIFY_CENTER, 671 JUSTIFY_FILL 672 }; 673 674 } // namespace Gtk 675 676 #ifndef DOXYGEN_SHOULD_SKIP_THIS 677 namespace Glib 678 { 679 680 template <> 681 class Value<Gtk::Justification> : public Glib::Value_Enum<Gtk::Justification> 682 { 683 public: 684 static GType value_type() G_GNUC_CONST; 685 }; 686 687 } // namespace Glib 688 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 689 690 namespace Gtk 691 { 692 693 /** 694 * @var MenuDirectionType MENU_DIR_PARENT 695 * To the parent menu shell. 696 * 697 * @var MenuDirectionType MENU_DIR_CHILD 698 * To the submenu, if any, associated with the item. 699 * 700 * @var MenuDirectionType MENU_DIR_NEXT 701 * To the next menu item. 702 * 703 * @var MenuDirectionType MENU_DIR_PREV 704 * To the previous menu item. 705 * 706 * @enum MenuDirectionType 707 * 708 * An enumeration representing directional movements within a menu. 709 * 710 * @ingroup gtkmmEnums 711 */ 712 enum MenuDirectionType 713 { 714 MENU_DIR_PARENT, 715 MENU_DIR_CHILD, 716 MENU_DIR_NEXT, 717 MENU_DIR_PREV 718 }; 719 720 } // namespace Gtk 721 722 #ifndef DOXYGEN_SHOULD_SKIP_THIS 723 namespace Glib 724 { 725 726 template <> 727 class Value<Gtk::MenuDirectionType> : public Glib::Value_Enum<Gtk::MenuDirectionType> 728 { 729 public: 730 static GType value_type() G_GNUC_CONST; 731 }; 732 733 } // namespace Glib 734 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 735 736 namespace Gtk 737 { 738 739 /** 740 * @var MessageType MESSAGE_INFO 741 * Informational message. 742 * 743 * @var MessageType MESSAGE_WARNING 744 * Non-fatal warning message. 745 * 746 * @var MessageType MESSAGE_QUESTION 747 * Question requiring a choice. 748 * 749 * @var MessageType MESSAGE_ERROR 750 * Fatal error message. 751 * 752 * @var MessageType MESSAGE_OTHER 753 * None of the above. 754 * 755 * @enum MessageType 756 * 757 * The type of message being displayed in the dialog. 758 * 759 * @ingroup gtkmmEnums 760 */ 761 enum MessageType 762 { 763 MESSAGE_INFO, 764 MESSAGE_WARNING, 765 MESSAGE_QUESTION, 766 MESSAGE_ERROR, 767 MESSAGE_OTHER 768 }; 769 770 } // namespace Gtk 771 772 #ifndef DOXYGEN_SHOULD_SKIP_THIS 773 namespace Glib 774 { 775 776 template <> 777 class Value<Gtk::MessageType> : public Glib::Value_Enum<Gtk::MessageType> 778 { 779 public: 780 static GType value_type() G_GNUC_CONST; 781 }; 782 783 } // namespace Glib 784 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 785 786 namespace Gtk 787 { 788 789 /** 790 * @var MovementStep MOVEMENT_LOGICAL_POSITIONS 791 * Move forward or back by graphemes. 792 * 793 * @var MovementStep MOVEMENT_VISUAL_POSITIONS 794 * Move left or right by graphemes. 795 * 796 * @var MovementStep MOVEMENT_WORDS 797 * Move forward or back by words. 798 * 799 * @var MovementStep MOVEMENT_DISPLAY_LINES 800 * Move up or down lines (wrapped lines). 801 * 802 * @var MovementStep MOVEMENT_DISPLAY_LINE_ENDS 803 * Move to either end of a line. 804 * 805 * @var MovementStep MOVEMENT_PARAGRAPHS 806 * Move up or down paragraphs (newline-ended lines). 807 * 808 * @var MovementStep MOVEMENT_PARAGRAPH_ENDS 809 * Move to either end of a paragraph. 810 * 811 * @var MovementStep MOVEMENT_PAGES 812 * Move by pages. 813 * 814 * @var MovementStep MOVEMENT_BUFFER_ENDS 815 * Move to ends of the buffer. 816 * 817 * @var MovementStep MOVEMENT_HORIZONTAL_PAGES 818 * Move horizontally by pages. 819 * 820 * @enum MovementStep 821 * 822 * @ingroup gtkmmEnums 823 */ 824 enum MovementStep 825 { 826 MOVEMENT_LOGICAL_POSITIONS, 827 MOVEMENT_VISUAL_POSITIONS, 828 MOVEMENT_WORDS, 829 MOVEMENT_DISPLAY_LINES, 830 MOVEMENT_DISPLAY_LINE_ENDS, 831 MOVEMENT_PARAGRAPHS, 832 MOVEMENT_PARAGRAPH_ENDS, 833 MOVEMENT_PAGES, 834 MOVEMENT_BUFFER_ENDS, 835 MOVEMENT_HORIZONTAL_PAGES 836 }; 837 838 } // namespace Gtk 839 840 #ifndef DOXYGEN_SHOULD_SKIP_THIS 841 namespace Glib 842 { 843 844 template <> 845 class Value<Gtk::MovementStep> : public Glib::Value_Enum<Gtk::MovementStep> 846 { 847 public: 848 static GType value_type() G_GNUC_CONST; 849 }; 850 851 } // namespace Glib 852 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 853 854 namespace Gtk 855 { 856 857 /** 858 * @var Orientation ORIENTATION_HORIZONTAL 859 * The element is in horizontal orientation. 860 * 861 * @var Orientation ORIENTATION_VERTICAL 862 * The element is in vertical orientation. 863 * 864 * @enum Orientation 865 * 866 * Represents the orientation of widgets and other objects which can be switched 867 * between horizontal and vertical orientation on the fly, like Gtk::Toolbar or 868 * Gtk::GesturePan. 869 * 870 * @ingroup gtkmmEnums 871 */ 872 enum Orientation 873 { 874 ORIENTATION_HORIZONTAL, 875 ORIENTATION_VERTICAL 876 }; 877 878 } // namespace Gtk 879 880 #ifndef DOXYGEN_SHOULD_SKIP_THIS 881 namespace Glib 882 { 883 884 template <> 885 class Value<Gtk::Orientation> : public Glib::Value_Enum<Gtk::Orientation> 886 { 887 public: 888 static GType value_type() G_GNUC_CONST; 889 }; 890 891 } // namespace Glib 892 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 893 894 namespace Gtk 895 { 896 897 /** 898 * @var CornerType CORNER_TOP_LEFT 899 * Place the scrollbars on the right and bottom of the 900 * widget (default behaviour). 901 * 902 * @var CornerType CORNER_BOTTOM_LEFT 903 * Place the scrollbars on the top and right of the 904 * widget. 905 * 906 * @var CornerType CORNER_TOP_RIGHT 907 * Place the scrollbars on the left and bottom of the 908 * widget. 909 * 910 * @var CornerType CORNER_BOTTOM_RIGHT 911 * Place the scrollbars on the top and left of the 912 * widget. 913 * 914 * @enum CornerType 915 * 916 * Specifies which corner a child widget should be placed in when packed into 917 * a Gtk::ScrolledWindow. This is effectively the opposite of where the scroll 918 * bars are placed. 919 * 920 * @ingroup gtkmmEnums 921 */ 922 enum CornerType 923 { 924 CORNER_TOP_LEFT, 925 CORNER_BOTTOM_LEFT, 926 CORNER_TOP_RIGHT, 927 CORNER_BOTTOM_RIGHT 928 }; 929 930 } // namespace Gtk 931 932 #ifndef DOXYGEN_SHOULD_SKIP_THIS 933 namespace Glib 934 { 935 936 template <> 937 class Value<Gtk::CornerType> : public Glib::Value_Enum<Gtk::CornerType> 938 { 939 public: 940 static GType value_type() G_GNUC_CONST; 941 }; 942 943 } // namespace Glib 944 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 945 946 namespace Gtk 947 { 948 949 /** 950 * @var PackType PACK_START 951 * The child is packed into the start of the box. 952 * 953 * @var PackType PACK_END 954 * The child is packed into the end of the box. 955 * 956 * @enum PackType 957 * 958 * Represents the packing location Gtk::Box children. (See: Gtk::VBox, 959 * Gtk::HBox, and Gtk::ButtonBox). 960 * 961 * @ingroup gtkmmEnums 962 */ 963 enum PackType 964 { 965 PACK_START, 966 PACK_END 967 }; 968 969 } // namespace Gtk 970 971 #ifndef DOXYGEN_SHOULD_SKIP_THIS 972 namespace Glib 973 { 974 975 template <> 976 class Value<Gtk::PackType> : public Glib::Value_Enum<Gtk::PackType> 977 { 978 public: 979 static GType value_type() G_GNUC_CONST; 980 }; 981 982 } // namespace Glib 983 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 984 985 namespace Gtk 986 { 987 988 /** 989 * @var PathPriorityType PATH_PRIO_LOWEST 990 * Deprecated. 991 * 992 * @var PathPriorityType PATH_PRIO_GTK 993 * Deprecated. 994 * 995 * @var PathPriorityType PATH_PRIO_APPLICATION 996 * Deprecated. 997 * 998 * @var PathPriorityType PATH_PRIO_THEME 999 * Deprecated. 1000 * 1001 * @var PathPriorityType PATH_PRIO_RC 1002 * Deprecated. 1003 * 1004 * @var PathPriorityType PATH_PRIO_HIGHEST 1005 * Deprecated. 1006 * 1007 * @enum PathPriorityType 1008 * 1009 * Priorities for path lookups. 1010 * See also gtk_binding_set_add_path(). 1011 * 1012 * Deprecated: 3.0 1013 * 1014 * @ingroup gtkmmEnums 1015 */ 1016 enum PathPriorityType 1017 { 1018 PATH_PRIO_LOWEST = 0, 1019 PATH_PRIO_GTK = 4, 1020 PATH_PRIO_APPLICATION = 8, 1021 PATH_PRIO_THEME = 10, 1022 PATH_PRIO_RC = 12, 1023 PATH_PRIO_HIGHEST = 15 1024 }; 1025 1026 } // namespace Gtk 1027 1028 #ifndef DOXYGEN_SHOULD_SKIP_THIS 1029 namespace Glib 1030 { 1031 1032 template <> 1033 class Value<Gtk::PathPriorityType> : public Glib::Value_Enum<Gtk::PathPriorityType> 1034 { 1035 public: 1036 static GType value_type() G_GNUC_CONST; 1037 }; 1038 1039 } // namespace Glib 1040 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 1041 1042 namespace Gtk 1043 { 1044 1045 /** 1046 * @var PathType PATH_WIDGET 1047 * Deprecated. 1048 * 1049 * @var PathType PATH_WIDGET_CLASS 1050 * Deprecated. 1051 * 1052 * @var PathType PATH_CLASS 1053 * Deprecated. 1054 * 1055 * @enum PathType 1056 * 1057 * Widget path types. 1058 * See also gtk_binding_set_add_path(). 1059 * 1060 * Deprecated: 3.0 1061 * 1062 * @ingroup gtkmmEnums 1063 */ 1064 enum PathType 1065 { 1066 PATH_WIDGET, 1067 PATH_WIDGET_CLASS, 1068 PATH_CLASS 1069 }; 1070 1071 } // namespace Gtk 1072 1073 #ifndef DOXYGEN_SHOULD_SKIP_THIS 1074 namespace Glib 1075 { 1076 1077 template <> 1078 class Value<Gtk::PathType> : public Glib::Value_Enum<Gtk::PathType> 1079 { 1080 public: 1081 static GType value_type() G_GNUC_CONST; 1082 }; 1083 1084 } // namespace Glib 1085 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 1086 1087 namespace Gtk 1088 { 1089 1090 /** 1091 * @var PlacesOpenFlags PLACES_OPEN_NORMAL 1092 * This is the default mode that Gtk::PlacesSidebar uses if no other flags 1093 * are specified. It indicates that the calling application should open the selected location 1094 * in the normal way, for example, in the folder view beside the sidebar. 1095 * 1096 * @var PlacesOpenFlags PLACES_OPEN_NEW_TAB 1097 * When passed to Gtk::PlacesSidebar::set_open_flags(), this indicates 1098 * that the application can open folders selected from the sidebar in new tabs. This value 1099 * will be passed to the Gtk::PlacesSidebar::signal_open_location() signal when the user selects 1100 * that a location be opened in a new tab instead of in the standard fashion. 1101 * 1102 * @var PlacesOpenFlags PLACES_OPEN_NEW_WINDOW 1103 * Similar to @a GTK_PLACES_OPEN_NEW_TAB, but indicates that the application 1104 * can open folders in new windows. 1105 * 1106 * @enum PlacesOpenFlags 1107 * 1108 * These flags serve two purposes. First, the application can call Gtk::PlacesSidebar::set_open_flags() 1109 * using these flags as a bitmask. This tells the sidebar that the application is able to open 1110 * folders selected from the sidebar in various ways, for example, in new tabs or in new windows in 1111 * addition to the normal mode. 1112 * 1113 * Second, when one of these values gets passed back to the application in the 1114 * Gtk::PlacesSidebar::signal_open_location() signal, it means that the application should 1115 * open the selected location in the normal way, in a new tab, or in a new 1116 * window. The sidebar takes care of determining the desired way to open the location, 1117 * based on the modifier keys that the user is pressing at the time the selection is made. 1118 * 1119 * If the application never calls Gtk::PlacesSidebar::set_open_flags(), then the sidebar will only 1120 * use Gtk::PLACES_OPEN_NORMAL in the Gtk::PlacesSidebar::signal_open_location() signal. This is the 1121 * default mode of operation. 1122 * 1123 * @ingroup gtkmmEnums 1124 * @par Bitwise operators: 1125 * <tt>%PlacesOpenFlags operator|(PlacesOpenFlags, PlacesOpenFlags)</tt><br> 1126 * <tt>%PlacesOpenFlags operator&(PlacesOpenFlags, PlacesOpenFlags)</tt><br> 1127 * <tt>%PlacesOpenFlags operator^(PlacesOpenFlags, PlacesOpenFlags)</tt><br> 1128 * <tt>%PlacesOpenFlags operator~(PlacesOpenFlags)</tt><br> 1129 * <tt>%PlacesOpenFlags& operator|=(PlacesOpenFlags&, PlacesOpenFlags)</tt><br> 1130 * <tt>%PlacesOpenFlags& operator&=(PlacesOpenFlags&, PlacesOpenFlags)</tt><br> 1131 * <tt>%PlacesOpenFlags& operator^=(PlacesOpenFlags&, PlacesOpenFlags)</tt><br> 1132 */ 1133 enum PlacesOpenFlags 1134 { 1135 PLACES_OPEN_NORMAL = 1 << 0, 1136 PLACES_OPEN_NEW_TAB = 1 << 1, 1137 PLACES_OPEN_NEW_WINDOW = 1 << 2 1138 }; 1139 1140 /** @ingroup gtkmmEnums */ 1141 inline PlacesOpenFlags operator|(PlacesOpenFlags lhs, PlacesOpenFlags rhs) 1142 { return static_cast<PlacesOpenFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); } 1143 1144 /** @ingroup gtkmmEnums */ 1145 inline PlacesOpenFlags operator&(PlacesOpenFlags lhs, PlacesOpenFlags rhs) 1146 { return static_cast<PlacesOpenFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); } 1147 1148 /** @ingroup gtkmmEnums */ 1149 inline PlacesOpenFlags operator^(PlacesOpenFlags lhs, PlacesOpenFlags rhs) 1150 { return static_cast<PlacesOpenFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); } 1151 1152 /** @ingroup gtkmmEnums */ 1153 inline PlacesOpenFlags operator~(PlacesOpenFlags flags) 1154 { return static_cast<PlacesOpenFlags>(~static_cast<unsigned>(flags)); } 1155 1156 /** @ingroup gtkmmEnums */ 1157 inline PlacesOpenFlags& operator|=(PlacesOpenFlags& lhs, PlacesOpenFlags rhs) 1158 { return (lhs = static_cast<PlacesOpenFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); } 1159 1160 /** @ingroup gtkmmEnums */ 1161 inline PlacesOpenFlags& operator&=(PlacesOpenFlags& lhs, PlacesOpenFlags rhs) 1162 { return (lhs = static_cast<PlacesOpenFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); } 1163 1164 /** @ingroup gtkmmEnums */ 1165 inline PlacesOpenFlags& operator^=(PlacesOpenFlags& lhs, PlacesOpenFlags rhs) 1166 { return (lhs = static_cast<PlacesOpenFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); } 1167 1168 } // namespace Gtk 1169 1170 #ifndef DOXYGEN_SHOULD_SKIP_THIS 1171 namespace Glib 1172 { 1173 1174 template <> 1175 class Value<Gtk::PlacesOpenFlags> : public Glib::Value_Flags<Gtk::PlacesOpenFlags> 1176 { 1177 public: 1178 static GType value_type() G_GNUC_CONST; 1179 }; 1180 1181 } // namespace Glib 1182 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 1183 1184 namespace Gtk 1185 { 1186 1187 /** 1188 * @var PolicyType POLICY_ALWAYS 1189 * The scrollbar is always visible. The view size is 1190 * independent of the content. 1191 * 1192 * @var PolicyType POLICY_AUTOMATIC 1193 * The scrollbar will appear and disappear as necessary. 1194 * For example, when all of a Gtk::TreeView can not be seen. 1195 * 1196 * @var PolicyType POLICY_NEVER 1197 * The scrollbar should never appear. In this mode the 1198 * content determines the size. 1199 * 1200 * @var PolicyType POLICY_EXTERNAL 1201 * Don't show a scrollbar, but don't force the 1202 * size to follow the content. This can be used e.g. to make multiple 1203 * scrolled windows share a scrollbar. @newin{3,16} 1204 * 1205 * @enum PolicyType 1206 * 1207 * Determines how the size should be computed to achieve the one of the 1208 * visibility mode for the scrollbars. 1209 * 1210 * @ingroup gtkmmEnums 1211 */ 1212 enum PolicyType 1213 { 1214 POLICY_ALWAYS, 1215 POLICY_AUTOMATIC, 1216 POLICY_NEVER, 1217 POLICY_EXTERNAL 1218 }; 1219 1220 } // namespace Gtk 1221 1222 #ifndef DOXYGEN_SHOULD_SKIP_THIS 1223 namespace Glib 1224 { 1225 1226 template <> 1227 class Value<Gtk::PolicyType> : public Glib::Value_Enum<Gtk::PolicyType> 1228 { 1229 public: 1230 static GType value_type() G_GNUC_CONST; 1231 }; 1232 1233 } // namespace Glib 1234 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 1235 1236 namespace Gtk 1237 { 1238 1239 /** 1240 * @var PositionType POS_LEFT 1241 * The feature is at the left edge. 1242 * 1243 * @var PositionType POS_RIGHT 1244 * The feature is at the right edge. 1245 * 1246 * @var PositionType POS_TOP 1247 * The feature is at the top edge. 1248 * 1249 * @var PositionType POS_BOTTOM 1250 * The feature is at the bottom edge. 1251 * 1252 * @enum PositionType 1253 * 1254 * Describes which edge of a widget a certain feature is positioned at, e.g. the 1255 * tabs of a Gtk::Notebook, the handle of a Gtk::HandleBox or the label of a 1256 * Gtk::Scale. 1257 * 1258 * @ingroup gtkmmEnums 1259 */ 1260 enum PositionType 1261 { 1262 POS_LEFT, 1263 POS_RIGHT, 1264 POS_TOP, 1265 POS_BOTTOM 1266 }; 1267 1268 } // namespace Gtk 1269 1270 #ifndef DOXYGEN_SHOULD_SKIP_THIS 1271 namespace Glib 1272 { 1273 1274 template <> 1275 class Value<Gtk::PositionType> : public Glib::Value_Enum<Gtk::PositionType> 1276 { 1277 public: 1278 static GType value_type() G_GNUC_CONST; 1279 }; 1280 1281 } // namespace Glib 1282 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 1283 1284 namespace Gtk 1285 { 1286 1287 /** 1288 * @var ReliefStyle RELIEF_NORMAL 1289 * Draw a normal relief. 1290 * 1291 * @var ReliefStyle RELIEF_HALF 1292 * A half relief. Deprecated in 3.14, does the same as @a GTK_RELIEF_NORMAL. 1293 * 1294 * @var ReliefStyle RELIEF_NONE 1295 * No relief. 1296 * 1297 * @enum ReliefStyle 1298 * 1299 * Indicated the relief to be drawn around a Gtk::Button. 1300 * 1301 * @ingroup gtkmmEnums 1302 */ 1303 enum ReliefStyle 1304 { 1305 RELIEF_NORMAL, 1306 RELIEF_HALF, 1307 RELIEF_NONE 1308 }; 1309 1310 } // namespace Gtk 1311 1312 #ifndef DOXYGEN_SHOULD_SKIP_THIS 1313 namespace Glib 1314 { 1315 1316 template <> 1317 class Value<Gtk::ReliefStyle> : public Glib::Value_Enum<Gtk::ReliefStyle> 1318 { 1319 public: 1320 static GType value_type() G_GNUC_CONST; 1321 }; 1322 1323 } // namespace Glib 1324 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 1325 1326 namespace Gtk 1327 { 1328 1329 /** 1330 * @var ResizeMode RESIZE_PARENT 1331 * Pass resize request to the parent. 1332 * 1333 * @var ResizeMode RESIZE_QUEUE 1334 * Queue resizes on this widget. 1335 * 1336 * @var ResizeMode RESIZE_IMMEDIATE 1337 * Resize immediately. Deprecated. 1338 * 1339 * @enum ResizeMode 1340 * 1341 * @ingroup gtkmmEnums 1342 */ 1343 enum ResizeMode 1344 { 1345 RESIZE_PARENT, 1346 RESIZE_QUEUE, 1347 RESIZE_IMMEDIATE 1348 }; 1349 1350 } // namespace Gtk 1351 1352 #ifndef DOXYGEN_SHOULD_SKIP_THIS 1353 namespace Glib 1354 { 1355 1356 template <> 1357 class Value<Gtk::ResizeMode> : public Glib::Value_Enum<Gtk::ResizeMode> 1358 { 1359 public: 1360 static GType value_type() G_GNUC_CONST; 1361 }; 1362 1363 } // namespace Glib 1364 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 1365 1366 namespace Gtk 1367 { 1368 1369 /** 1370 * @var RevealerTransitionType REVEALER_TRANSITION_TYPE_NONE 1371 * No transition. 1372 * 1373 * @var RevealerTransitionType REVEALER_TRANSITION_TYPE_CROSSFADE 1374 * Fade in. 1375 * 1376 * @var RevealerTransitionType REVEALER_TRANSITION_TYPE_SLIDE_RIGHT 1377 * Slide in from the left. 1378 * 1379 * @var RevealerTransitionType REVEALER_TRANSITION_TYPE_SLIDE_LEFT 1380 * Slide in from the right. 1381 * 1382 * @var RevealerTransitionType REVEALER_TRANSITION_TYPE_SLIDE_UP 1383 * Slide in from the bottom. 1384 * 1385 * @var RevealerTransitionType REVEALER_TRANSITION_TYPE_SLIDE_DOWN 1386 * Slide in from the top. 1387 * 1388 * @enum RevealerTransitionType 1389 * 1390 * These enumeration values describe the possible transitions 1391 * when the child of a Gtk::Revealer widget is shown or hidden. 1392 * 1393 * @ingroup gtkmmEnums 1394 */ 1395 enum RevealerTransitionType 1396 { 1397 REVEALER_TRANSITION_TYPE_NONE, 1398 REVEALER_TRANSITION_TYPE_CROSSFADE, 1399 REVEALER_TRANSITION_TYPE_SLIDE_RIGHT, 1400 REVEALER_TRANSITION_TYPE_SLIDE_LEFT, 1401 REVEALER_TRANSITION_TYPE_SLIDE_UP, 1402 REVEALER_TRANSITION_TYPE_SLIDE_DOWN 1403 }; 1404 1405 } // namespace Gtk 1406 1407 #ifndef DOXYGEN_SHOULD_SKIP_THIS 1408 namespace Glib 1409 { 1410 1411 template <> 1412 class Value<Gtk::RevealerTransitionType> : public Glib::Value_Enum<Gtk::RevealerTransitionType> 1413 { 1414 public: 1415 static GType value_type() G_GNUC_CONST; 1416 }; 1417 1418 } // namespace Glib 1419 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 1420 1421 namespace Gtk 1422 { 1423 1424 /** 1425 * @var ScrollType SCROLL_NONE 1426 * No scrolling. 1427 * 1428 * @var ScrollType SCROLL_JUMP 1429 * Jump to new location. 1430 * 1431 * @var ScrollType SCROLL_STEP_BACKWARD 1432 * Step backward. 1433 * 1434 * @var ScrollType SCROLL_STEP_FORWARD 1435 * Step forward. 1436 * 1437 * @var ScrollType SCROLL_PAGE_BACKWARD 1438 * Page backward. 1439 * 1440 * @var ScrollType SCROLL_PAGE_FORWARD 1441 * Page forward. 1442 * 1443 * @var ScrollType SCROLL_STEP_UP 1444 * Step up. 1445 * 1446 * @var ScrollType SCROLL_STEP_DOWN 1447 * Step down. 1448 * 1449 * @var ScrollType SCROLL_PAGE_UP 1450 * Page up. 1451 * 1452 * @var ScrollType SCROLL_PAGE_DOWN 1453 * Page down. 1454 * 1455 * @var ScrollType SCROLL_STEP_LEFT 1456 * Step to the left. 1457 * 1458 * @var ScrollType SCROLL_STEP_RIGHT 1459 * Step to the right. 1460 * 1461 * @var ScrollType SCROLL_PAGE_LEFT 1462 * Page to the left. 1463 * 1464 * @var ScrollType SCROLL_PAGE_RIGHT 1465 * Page to the right. 1466 * 1467 * @var ScrollType SCROLL_START 1468 * Scroll to start. 1469 * 1470 * @var ScrollType SCROLL_END 1471 * Scroll to end. 1472 * 1473 * @enum ScrollType 1474 * 1475 * Scrolling types. 1476 * 1477 * @ingroup gtkmmEnums 1478 */ 1479 enum ScrollType 1480 { 1481 SCROLL_NONE, 1482 SCROLL_JUMP, 1483 SCROLL_STEP_BACKWARD, 1484 SCROLL_STEP_FORWARD, 1485 SCROLL_PAGE_BACKWARD, 1486 SCROLL_PAGE_FORWARD, 1487 SCROLL_STEP_UP, 1488 SCROLL_STEP_DOWN, 1489 SCROLL_PAGE_UP, 1490 SCROLL_PAGE_DOWN, 1491 SCROLL_STEP_LEFT, 1492 SCROLL_STEP_RIGHT, 1493 SCROLL_PAGE_LEFT, 1494 SCROLL_PAGE_RIGHT, 1495 SCROLL_START, 1496 SCROLL_END 1497 }; 1498 1499 } // namespace Gtk 1500 1501 #ifndef DOXYGEN_SHOULD_SKIP_THIS 1502 namespace Glib 1503 { 1504 1505 template <> 1506 class Value<Gtk::ScrollType> : public Glib::Value_Enum<Gtk::ScrollType> 1507 { 1508 public: 1509 static GType value_type() G_GNUC_CONST; 1510 }; 1511 1512 } // namespace Glib 1513 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 1514 1515 namespace Gtk 1516 { 1517 1518 /** 1519 * @var SelectionMode SELECTION_NONE 1520 * No selection is possible. 1521 * 1522 * @var SelectionMode SELECTION_SINGLE 1523 * Zero or one element may be selected. 1524 * 1525 * @var SelectionMode SELECTION_BROWSE 1526 * Exactly one element is selected. 1527 * In some circumstances, such as initially or during a search 1528 * operation, it’s possible for no element to be selected with 1529 * Gtk::SELECTION_BROWSE. What is really enforced is that the user 1530 * can’t deselect a currently selected element except by selecting 1531 * another element. 1532 * 1533 * @var SelectionMode SELECTION_MULTIPLE 1534 * Any number of elements may be selected. 1535 * The Ctrl key may be used to enlarge the selection, and Shift 1536 * key to select between the focus and the child pointed to. 1537 * Some widgets may also allow Click-drag to select a range of elements. 1538 * 1539 * @enum SelectionMode 1540 * 1541 * Used to control what selections users are allowed to make. 1542 * 1543 * @ingroup gtkmmEnums 1544 */ 1545 enum SelectionMode 1546 { 1547 SELECTION_NONE, 1548 SELECTION_SINGLE, 1549 SELECTION_BROWSE, 1550 SELECTION_MULTIPLE 1551 }; 1552 1553 } // namespace Gtk 1554 1555 #ifndef DOXYGEN_SHOULD_SKIP_THIS 1556 namespace Glib 1557 { 1558 1559 template <> 1560 class Value<Gtk::SelectionMode> : public Glib::Value_Enum<Gtk::SelectionMode> 1561 { 1562 public: 1563 static GType value_type() G_GNUC_CONST; 1564 }; 1565 1566 } // namespace Glib 1567 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 1568 1569 namespace Gtk 1570 { 1571 1572 /** 1573 * @var ShadowType SHADOW_NONE 1574 * No outline. 1575 * 1576 * @var ShadowType SHADOW_IN 1577 * The outline is bevelled inwards. 1578 * 1579 * @var ShadowType SHADOW_OUT 1580 * The outline is bevelled outwards like a button. 1581 * 1582 * @var ShadowType SHADOW_ETCHED_IN 1583 * The outline has a sunken 3d appearance. 1584 * 1585 * @var ShadowType SHADOW_ETCHED_OUT 1586 * The outline has a raised 3d appearance. 1587 * 1588 * @enum ShadowType 1589 * 1590 * Used to change the appearance of an outline typically provided by a Gtk::Frame. 1591 * 1592 * Note that many themes do not differentiate the appearance of the 1593 * various shadow types: Either their is no visible shadow ( @a GTK_SHADOW_NONE), 1594 * or there is (any other value). 1595 * 1596 * @ingroup gtkmmEnums 1597 */ 1598 enum ShadowType 1599 { 1600 SHADOW_NONE, 1601 SHADOW_IN, 1602 SHADOW_OUT, 1603 SHADOW_ETCHED_IN, 1604 SHADOW_ETCHED_OUT 1605 }; 1606 1607 } // namespace Gtk 1608 1609 #ifndef DOXYGEN_SHOULD_SKIP_THIS 1610 namespace Glib 1611 { 1612 1613 template <> 1614 class Value<Gtk::ShadowType> : public Glib::Value_Enum<Gtk::ShadowType> 1615 { 1616 public: 1617 static GType value_type() G_GNUC_CONST; 1618 }; 1619 1620 } // namespace Glib 1621 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 1622 1623 namespace Gtk 1624 { 1625 1626 /** 1627 * @var StackTransitionType STACK_TRANSITION_TYPE_NONE 1628 * No transition. 1629 * 1630 * @var StackTransitionType STACK_TRANSITION_TYPE_CROSSFADE 1631 * A cross-fade. 1632 * 1633 * @var StackTransitionType STACK_TRANSITION_TYPE_SLIDE_RIGHT 1634 * Slide from left to right. 1635 * 1636 * @var StackTransitionType STACK_TRANSITION_TYPE_SLIDE_LEFT 1637 * Slide from right to left. 1638 * 1639 * @var StackTransitionType STACK_TRANSITION_TYPE_SLIDE_UP 1640 * Slide from bottom up. 1641 * 1642 * @var StackTransitionType STACK_TRANSITION_TYPE_SLIDE_DOWN 1643 * Slide from top down. 1644 * 1645 * @var StackTransitionType STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT 1646 * Slide from left or right according to the children order. 1647 * 1648 * @var StackTransitionType STACK_TRANSITION_TYPE_SLIDE_UP_DOWN 1649 * Slide from top down or bottom up according to the order. 1650 * 1651 * @var StackTransitionType STACK_TRANSITION_TYPE_OVER_UP 1652 * Cover the old page by sliding up. @newin{3,12} 1653 * 1654 * @var StackTransitionType STACK_TRANSITION_TYPE_OVER_DOWN 1655 * Cover the old page by sliding down. @newin{3,12} 1656 * 1657 * @var StackTransitionType STACK_TRANSITION_TYPE_OVER_LEFT 1658 * Cover the old page by sliding to the left. @newin{3,12} 1659 * 1660 * @var StackTransitionType STACK_TRANSITION_TYPE_OVER_RIGHT 1661 * Cover the old page by sliding to the right. @newin{3,12} 1662 * 1663 * @var StackTransitionType STACK_TRANSITION_TYPE_UNDER_UP 1664 * Uncover the new page by sliding up. @newin{3,12} 1665 * 1666 * @var StackTransitionType STACK_TRANSITION_TYPE_UNDER_DOWN 1667 * Uncover the new page by sliding down. @newin{3,12} 1668 * 1669 * @var StackTransitionType STACK_TRANSITION_TYPE_UNDER_LEFT 1670 * Uncover the new page by sliding to the left. @newin{3,12} 1671 * 1672 * @var StackTransitionType STACK_TRANSITION_TYPE_UNDER_RIGHT 1673 * Uncover the new page by sliding to the right. @newin{3,12} 1674 * 1675 * @var StackTransitionType STACK_TRANSITION_TYPE_OVER_UP_DOWN 1676 * Cover the old page sliding up or uncover the new page sliding down, according to order. @newin{3,12} 1677 * 1678 * @var StackTransitionType STACK_TRANSITION_TYPE_OVER_DOWN_UP 1679 * Cover the old page sliding down or uncover the new page sliding up, according to order. @newin{3,14} 1680 * 1681 * @var StackTransitionType STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT 1682 * Cover the old page sliding left or uncover the new page sliding right, according to order. @newin{3,14} 1683 * 1684 * @var StackTransitionType STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT 1685 * Cover the old page sliding right or uncover the new page sliding left, according to order. @newin{3,14} 1686 * 1687 * @enum StackTransitionType 1688 * 1689 * These enumeration values describe the possible transitions 1690 * between pages in a Gtk::Stack widget. 1691 * 1692 * New values may be added to this enumeration over time. 1693 * 1694 * @ingroup gtkmmEnums 1695 */ 1696 enum StackTransitionType 1697 { 1698 STACK_TRANSITION_TYPE_NONE, 1699 STACK_TRANSITION_TYPE_CROSSFADE, 1700 STACK_TRANSITION_TYPE_SLIDE_RIGHT, 1701 STACK_TRANSITION_TYPE_SLIDE_LEFT, 1702 STACK_TRANSITION_TYPE_SLIDE_UP, 1703 STACK_TRANSITION_TYPE_SLIDE_DOWN, 1704 STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT, 1705 STACK_TRANSITION_TYPE_SLIDE_UP_DOWN, 1706 STACK_TRANSITION_TYPE_OVER_UP, 1707 STACK_TRANSITION_TYPE_OVER_DOWN, 1708 STACK_TRANSITION_TYPE_OVER_LEFT, 1709 STACK_TRANSITION_TYPE_OVER_RIGHT, 1710 STACK_TRANSITION_TYPE_UNDER_UP, 1711 STACK_TRANSITION_TYPE_UNDER_DOWN, 1712 STACK_TRANSITION_TYPE_UNDER_LEFT, 1713 STACK_TRANSITION_TYPE_UNDER_RIGHT, 1714 STACK_TRANSITION_TYPE_OVER_UP_DOWN, 1715 STACK_TRANSITION_TYPE_OVER_DOWN_UP, 1716 STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT, 1717 STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT 1718 }; 1719 1720 } // namespace Gtk 1721 1722 #ifndef DOXYGEN_SHOULD_SKIP_THIS 1723 namespace Glib 1724 { 1725 1726 template <> 1727 class Value<Gtk::StackTransitionType> : public Glib::Value_Enum<Gtk::StackTransitionType> 1728 { 1729 public: 1730 static GType value_type() G_GNUC_CONST; 1731 }; 1732 1733 } // namespace Glib 1734 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 1735 1736 namespace Gtk 1737 { 1738 1739 /** 1740 * @var StateType STATE_NORMAL 1741 * State during normal operation. 1742 * 1743 * @var StateType STATE_ACTIVE 1744 * State of a currently active widget, such as a depressed button. 1745 * 1746 * @var StateType STATE_PRELIGHT 1747 * State indicating that the mouse pointer is over 1748 * the widget and the widget will respond to mouse clicks. 1749 * 1750 * @var StateType STATE_SELECTED 1751 * State of a selected item, such the selected row in a list. 1752 * 1753 * @var StateType STATE_INSENSITIVE 1754 * State indicating that the widget is 1755 * unresponsive to user actions. 1756 * 1757 * @var StateType STATE_INCONSISTENT 1758 * The widget is inconsistent, such as checkbuttons 1759 * or radiobuttons that aren’t either set to <tt>true</tt> nor <tt>false</tt>, 1760 * or buttons requiring the user attention. 1761 * 1762 * @var StateType STATE_FOCUSED 1763 * The widget has the keyboard focus. 1764 * 1765 * @enum StateType 1766 * 1767 * This type indicates the current state of a widget; the state determines how 1768 * the widget is drawn. The Gtk::StateType enumeration is also used to 1769 * identify different colors in a Gtk::Style for drawing, so states can be 1770 * used for subparts of a widget as well as entire widgets. 1771 * 1772 * Deprecated: 3.14: All APIs that are using this enumeration have been deprecated 1773 * in favor of alternatives using Gtk::StateFlags. 1774 * 1775 * @ingroup gtkmmEnums 1776 */ 1777 enum StateType 1778 { 1779 STATE_NORMAL, 1780 STATE_ACTIVE, 1781 STATE_PRELIGHT, 1782 STATE_SELECTED, 1783 STATE_INSENSITIVE, 1784 STATE_INCONSISTENT, 1785 STATE_FOCUSED 1786 }; 1787 1788 } // namespace Gtk 1789 1790 #ifndef DOXYGEN_SHOULD_SKIP_THIS 1791 namespace Glib 1792 { 1793 1794 template <> 1795 class Value<Gtk::StateType> : public Glib::Value_Enum<Gtk::StateType> 1796 { 1797 public: 1798 static GType value_type() G_GNUC_CONST; 1799 }; 1800 1801 } // namespace Glib 1802 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 1803 1804 namespace Gtk 1805 { 1806 1807 /** 1808 * @var TargetFlags TARGET_SAME_APP 1809 * If this is set, the target will only be selected 1810 * for drags within a single application. 1811 * 1812 * @var TargetFlags TARGET_SAME_WIDGET 1813 * If this is set, the target will only be selected 1814 * for drags within a single widget. 1815 * 1816 * @var TargetFlags TARGET_OTHER_APP 1817 * If this is set, the target will not be selected 1818 * for drags within a single application. 1819 * 1820 * @var TargetFlags TARGET_OTHER_WIDGET 1821 * If this is set, the target will not be selected 1822 * for drags withing a single widget. 1823 * 1824 * @enum TargetFlags 1825 * 1826 * The Gtk::TargetFlags enumeration is used to specify 1827 * constraints on a Gtk::TargetEntry. 1828 * 1829 * @ingroup gtkmmEnums 1830 * @par Bitwise operators: 1831 * <tt>%TargetFlags operator|(TargetFlags, TargetFlags)</tt><br> 1832 * <tt>%TargetFlags operator&(TargetFlags, TargetFlags)</tt><br> 1833 * <tt>%TargetFlags operator^(TargetFlags, TargetFlags)</tt><br> 1834 * <tt>%TargetFlags operator~(TargetFlags)</tt><br> 1835 * <tt>%TargetFlags& operator|=(TargetFlags&, TargetFlags)</tt><br> 1836 * <tt>%TargetFlags& operator&=(TargetFlags&, TargetFlags)</tt><br> 1837 * <tt>%TargetFlags& operator^=(TargetFlags&, TargetFlags)</tt><br> 1838 */ 1839 enum TargetFlags 1840 { 1841 TARGET_SAME_APP = 1 << 0, 1842 TARGET_SAME_WIDGET = 1 << 1, 1843 TARGET_OTHER_APP = 1 << 2, 1844 TARGET_OTHER_WIDGET = 1 << 3 1845 }; 1846 1847 /** @ingroup gtkmmEnums */ 1848 inline TargetFlags operator|(TargetFlags lhs, TargetFlags rhs) 1849 { return static_cast<TargetFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); } 1850 1851 /** @ingroup gtkmmEnums */ 1852 inline TargetFlags operator&(TargetFlags lhs, TargetFlags rhs) 1853 { return static_cast<TargetFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); } 1854 1855 /** @ingroup gtkmmEnums */ 1856 inline TargetFlags operator^(TargetFlags lhs, TargetFlags rhs) 1857 { return static_cast<TargetFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); } 1858 1859 /** @ingroup gtkmmEnums */ 1860 inline TargetFlags operator~(TargetFlags flags) 1861 { return static_cast<TargetFlags>(~static_cast<unsigned>(flags)); } 1862 1863 /** @ingroup gtkmmEnums */ 1864 inline TargetFlags& operator|=(TargetFlags& lhs, TargetFlags rhs) 1865 { return (lhs = static_cast<TargetFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); } 1866 1867 /** @ingroup gtkmmEnums */ 1868 inline TargetFlags& operator&=(TargetFlags& lhs, TargetFlags rhs) 1869 { return (lhs = static_cast<TargetFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); } 1870 1871 /** @ingroup gtkmmEnums */ 1872 inline TargetFlags& operator^=(TargetFlags& lhs, TargetFlags rhs) 1873 { return (lhs = static_cast<TargetFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); } 1874 1875 } // namespace Gtk 1876 1877 #ifndef DOXYGEN_SHOULD_SKIP_THIS 1878 namespace Glib 1879 { 1880 1881 template <> 1882 class Value<Gtk::TargetFlags> : public Glib::Value_Flags<Gtk::TargetFlags> 1883 { 1884 public: 1885 static GType value_type() G_GNUC_CONST; 1886 }; 1887 1888 } // namespace Glib 1889 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 1890 1891 namespace Gtk 1892 { 1893 1894 /** 1895 * @var ToolbarStyle TOOLBAR_ICONS 1896 * Buttons display only icons in the toolbar. 1897 * 1898 * @var ToolbarStyle TOOLBAR_TEXT 1899 * Buttons display only text labels in the toolbar. 1900 * 1901 * @var ToolbarStyle TOOLBAR_BOTH 1902 * Buttons display text and icons in the toolbar. 1903 * 1904 * @var ToolbarStyle TOOLBAR_BOTH_HORIZ 1905 * Buttons display icons and text alongside each 1906 * other, rather than vertically stacked. 1907 * 1908 * @enum ToolbarStyle 1909 * 1910 * Used to customize the appearance of a Gtk::Toolbar. Note that 1911 * setting the toolbar style overrides the user’s preferences 1912 * for the default toolbar style. Note that if the button has only 1913 * a label set and GTK_TOOLBAR_ICONS is used, the label will be 1914 * visible, and vice versa. 1915 * 1916 * @ingroup gtkmmEnums 1917 */ 1918 enum ToolbarStyle 1919 { 1920 TOOLBAR_ICONS, 1921 TOOLBAR_TEXT, 1922 TOOLBAR_BOTH, 1923 TOOLBAR_BOTH_HORIZ 1924 }; 1925 1926 } // namespace Gtk 1927 1928 #ifndef DOXYGEN_SHOULD_SKIP_THIS 1929 namespace Glib 1930 { 1931 1932 template <> 1933 class Value<Gtk::ToolbarStyle> : public Glib::Value_Enum<Gtk::ToolbarStyle> 1934 { 1935 public: 1936 static GType value_type() G_GNUC_CONST; 1937 }; 1938 1939 } // namespace Glib 1940 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 1941 1942 namespace Gtk 1943 { 1944 1945 /** 1946 * @var WindowPosition WIN_POS_NONE 1947 * No influence is made on placement. 1948 * 1949 * @var WindowPosition WIN_POS_CENTER 1950 * Windows should be placed in the center of the screen. 1951 * 1952 * @var WindowPosition WIN_POS_MOUSE 1953 * Windows should be placed at the current mouse position. 1954 * 1955 * @var WindowPosition WIN_POS_CENTER_ALWAYS 1956 * Keep window centered as it changes size, etc. 1957 * 1958 * @var WindowPosition WIN_POS_CENTER_ON_PARENT 1959 * Center the window on its transient 1960 * parent (see Gtk::Window::set_transient_for()). 1961 * 1962 * @enum WindowPosition 1963 * 1964 * Window placement can be influenced using this enumeration. Note that 1965 * using Gtk::WIN_POS_CENTER_ALWAYS is almost always a bad idea. 1966 * It won’t necessarily work well with all window managers or on all windowing systems. 1967 * 1968 * @ingroup gtkmmEnums 1969 */ 1970 enum WindowPosition 1971 { 1972 WIN_POS_NONE, 1973 WIN_POS_CENTER, 1974 WIN_POS_MOUSE, 1975 WIN_POS_CENTER_ALWAYS, 1976 WIN_POS_CENTER_ON_PARENT 1977 }; 1978 1979 } // namespace Gtk 1980 1981 #ifndef DOXYGEN_SHOULD_SKIP_THIS 1982 namespace Glib 1983 { 1984 1985 template <> 1986 class Value<Gtk::WindowPosition> : public Glib::Value_Enum<Gtk::WindowPosition> 1987 { 1988 public: 1989 static GType value_type() G_GNUC_CONST; 1990 }; 1991 1992 } // namespace Glib 1993 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 1994 1995 namespace Gtk 1996 { 1997 1998 /** 1999 * @var WindowType WINDOW_TOPLEVEL 2000 * A regular window, such as a dialog. 2001 * 2002 * @var WindowType WINDOW_POPUP 2003 * A special window such as a tooltip. 2004 * 2005 * @enum WindowType 2006 * 2007 * A Gtk::Window can be one of these types. Most things you’d consider a 2008 * “window” should have type Gtk::WINDOW_TOPLEVEL; windows with this type 2009 * are managed by the window manager and have a frame by default (call 2010 * Gtk::Window::set_decorated() to toggle the frame). Windows with type 2011 * Gtk::WINDOW_POPUP are ignored by the window manager; window manager 2012 * keybindings won’t work on them, the window manager won’t decorate the 2013 * window with a frame, many GTK+ features that rely on the window 2014 * manager will not work (e.g. resize grips and 2015 * maximization/minimization). Gtk::WINDOW_POPUP is used to implement 2016 * widgets such as Gtk::Menu or tooltips that you normally don’t think of 2017 * as windows per se. Nearly all windows should be Gtk::WINDOW_TOPLEVEL. 2018 * In particular, do not use Gtk::WINDOW_POPUP just to turn off 2019 * the window borders; use Gtk::Window::set_decorated() for that. 2020 * 2021 * @ingroup gtkmmEnums 2022 */ 2023 enum WindowType 2024 { 2025 WINDOW_TOPLEVEL, 2026 WINDOW_POPUP 2027 }; 2028 2029 } // namespace Gtk 2030 2031 #ifndef DOXYGEN_SHOULD_SKIP_THIS 2032 namespace Glib 2033 { 2034 2035 template <> 2036 class Value<Gtk::WindowType> : public Glib::Value_Enum<Gtk::WindowType> 2037 { 2038 public: 2039 static GType value_type() G_GNUC_CONST; 2040 }; 2041 2042 } // namespace Glib 2043 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 2044 2045 namespace Gtk 2046 { 2047 2048 /** 2049 * @var WrapMode WRAP_NONE 2050 * Do not wrap lines; just make the text area wider. 2051 * 2052 * @var WrapMode WRAP_CHAR 2053 * Wrap text, breaking lines anywhere the cursor can 2054 * appear (between characters, usually - if you want to be technical, 2055 * between graphemes, see pango_get_log_attrs()). 2056 * 2057 * @var WrapMode WRAP_WORD 2058 * Wrap text, breaking lines in between words. 2059 * 2060 * @var WrapMode WRAP_WORD_CHAR 2061 * Wrap text, breaking lines in between words, or if 2062 * that is not enough, also between graphemes. 2063 * 2064 * @enum WrapMode 2065 * 2066 * Describes a type of line wrapping. 2067 * 2068 * @ingroup gtkmmEnums 2069 */ 2070 enum WrapMode 2071 { 2072 WRAP_NONE, 2073 WRAP_CHAR, 2074 WRAP_WORD, 2075 WRAP_WORD_CHAR 2076 }; 2077 2078 } // namespace Gtk 2079 2080 #ifndef DOXYGEN_SHOULD_SKIP_THIS 2081 namespace Glib 2082 { 2083 2084 template <> 2085 class Value<Gtk::WrapMode> : public Glib::Value_Enum<Gtk::WrapMode> 2086 { 2087 public: 2088 static GType value_type() G_GNUC_CONST; 2089 }; 2090 2091 } // namespace Glib 2092 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 2093 2094 namespace Gtk 2095 { 2096 2097 /** 2098 * @var SortType SORT_ASCENDING 2099 * Sorting is in ascending order. 2100 * 2101 * @var SortType SORT_DESCENDING 2102 * Sorting is in descending order. 2103 * 2104 * @enum SortType 2105 * 2106 * Determines the direction of a sort. 2107 * 2108 * @ingroup gtkmmEnums 2109 */ 2110 enum SortType 2111 { 2112 SORT_ASCENDING, 2113 SORT_DESCENDING 2114 }; 2115 2116 } // namespace Gtk 2117 2118 #ifndef DOXYGEN_SHOULD_SKIP_THIS 2119 namespace Glib 2120 { 2121 2122 template <> 2123 class Value<Gtk::SortType> : public Glib::Value_Enum<Gtk::SortType> 2124 { 2125 public: 2126 static GType value_type() G_GNUC_CONST; 2127 }; 2128 2129 } // namespace Glib 2130 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 2131 2132 namespace Gtk 2133 { 2134 2135 /** 2136 * @var PageOrientation PAGE_ORIENTATION_PORTRAIT 2137 * Portrait mode. 2138 * 2139 * @var PageOrientation PAGE_ORIENTATION_LANDSCAPE 2140 * Landscape mode. 2141 * 2142 * @var PageOrientation PAGE_ORIENTATION_REVERSE_PORTRAIT 2143 * Reverse portrait mode. 2144 * 2145 * @var PageOrientation PAGE_ORIENTATION_REVERSE_LANDSCAPE 2146 * Reverse landscape mode. 2147 * 2148 * @enum PageOrientation 2149 * 2150 * See also Gtk::PrintSettings::set_orientation(). 2151 * 2152 * @ingroup gtkmmEnums 2153 */ 2154 enum PageOrientation 2155 { 2156 PAGE_ORIENTATION_PORTRAIT, 2157 PAGE_ORIENTATION_LANDSCAPE, 2158 PAGE_ORIENTATION_REVERSE_PORTRAIT, 2159 PAGE_ORIENTATION_REVERSE_LANDSCAPE 2160 }; 2161 2162 } // namespace Gtk 2163 2164 #ifndef DOXYGEN_SHOULD_SKIP_THIS 2165 namespace Glib 2166 { 2167 2168 template <> 2169 class Value<Gtk::PageOrientation> : public Glib::Value_Enum<Gtk::PageOrientation> 2170 { 2171 public: 2172 static GType value_type() G_GNUC_CONST; 2173 }; 2174 2175 } // namespace Glib 2176 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 2177 2178 namespace Gtk 2179 { 2180 2181 /** 2182 * @var SensitivityType SENSITIVITY_AUTO 2183 * The arrow is made insensitive if the 2184 * thumb is at the end. 2185 * 2186 * @var SensitivityType SENSITIVITY_ON 2187 * The arrow is always sensitive. 2188 * 2189 * @var SensitivityType SENSITIVITY_OFF 2190 * The arrow is always insensitive. 2191 * 2192 * @enum SensitivityType 2193 * 2194 * Determines how GTK+ handles the sensitivity of stepper arrows 2195 * at the end of range widgets. 2196 * 2197 * @ingroup gtkmmEnums 2198 */ 2199 enum SensitivityType 2200 { 2201 SENSITIVITY_AUTO, 2202 SENSITIVITY_ON, 2203 SENSITIVITY_OFF 2204 }; 2205 2206 } // namespace Gtk 2207 2208 #ifndef DOXYGEN_SHOULD_SKIP_THIS 2209 namespace Glib 2210 { 2211 2212 template <> 2213 class Value<Gtk::SensitivityType> : public Glib::Value_Enum<Gtk::SensitivityType> 2214 { 2215 public: 2216 static GType value_type() G_GNUC_CONST; 2217 }; 2218 2219 } // namespace Glib 2220 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 2221 2222 namespace Gtk 2223 { 2224 2225 /** 2226 * @var SizeRequestMode SIZE_REQUEST_HEIGHT_FOR_WIDTH 2227 * Prefer height-for-width geometry management. 2228 * 2229 * @var SizeRequestMode SIZE_REQUEST_WIDTH_FOR_HEIGHT 2230 * Prefer width-for-height geometry management. 2231 * 2232 * @var SizeRequestMode SIZE_REQUEST_CONSTANT_SIZE 2233 * Don’t trade height-for-width or width-for-height. 2234 * 2235 * @enum SizeRequestMode 2236 * 2237 * Specifies a preference for height-for-width or 2238 * width-for-height geometry management. 2239 * 2240 * @ingroup gtkmmEnums 2241 */ 2242 enum SizeRequestMode 2243 { 2244 SIZE_REQUEST_HEIGHT_FOR_WIDTH, 2245 SIZE_REQUEST_WIDTH_FOR_HEIGHT, 2246 SIZE_REQUEST_CONSTANT_SIZE 2247 }; 2248 2249 } // namespace Gtk 2250 2251 #ifndef DOXYGEN_SHOULD_SKIP_THIS 2252 namespace Glib 2253 { 2254 2255 template <> 2256 class Value<Gtk::SizeRequestMode> : public Glib::Value_Enum<Gtk::SizeRequestMode> 2257 { 2258 public: 2259 static GType value_type() G_GNUC_CONST; 2260 }; 2261 2262 } // namespace Glib 2263 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 2264 2265 namespace Gtk 2266 { 2267 2268 /** 2269 * @var RegionFlags REGION_EVEN 2270 * Region has an even number within a set. 2271 * 2272 * @var RegionFlags REGION_ODD 2273 * Region has an odd number within a set. 2274 * 2275 * @var RegionFlags REGION_FIRST 2276 * Region is the first one within a set. 2277 * 2278 * @var RegionFlags REGION_LAST 2279 * Region is the last one within a set. 2280 * 2281 * @var RegionFlags REGION_ONLY 2282 * Region is the only one within a set. 2283 * 2284 * @var RegionFlags REGION_SORTED 2285 * Region is part of a sorted area. 2286 * 2287 * @enum RegionFlags 2288 * 2289 * Describes a region within a widget. 2290 * 2291 * @ingroup gtkmmEnums 2292 * @par Bitwise operators: 2293 * <tt>%RegionFlags operator|(RegionFlags, RegionFlags)</tt><br> 2294 * <tt>%RegionFlags operator&(RegionFlags, RegionFlags)</tt><br> 2295 * <tt>%RegionFlags operator^(RegionFlags, RegionFlags)</tt><br> 2296 * <tt>%RegionFlags operator~(RegionFlags)</tt><br> 2297 * <tt>%RegionFlags& operator|=(RegionFlags&, RegionFlags)</tt><br> 2298 * <tt>%RegionFlags& operator&=(RegionFlags&, RegionFlags)</tt><br> 2299 * <tt>%RegionFlags& operator^=(RegionFlags&, RegionFlags)</tt><br> 2300 */ 2301 enum RegionFlags 2302 { 2303 REGION_EVEN = 1 << 0, 2304 REGION_ODD = 1 << 1, 2305 REGION_FIRST = 1 << 2, 2306 REGION_LAST = 1 << 3, 2307 REGION_ONLY = 1 << 4, 2308 REGION_SORTED = 1 << 5 2309 }; 2310 2311 /** @ingroup gtkmmEnums */ 2312 inline RegionFlags operator|(RegionFlags lhs, RegionFlags rhs) 2313 { return static_cast<RegionFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); } 2314 2315 /** @ingroup gtkmmEnums */ 2316 inline RegionFlags operator&(RegionFlags lhs, RegionFlags rhs) 2317 { return static_cast<RegionFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); } 2318 2319 /** @ingroup gtkmmEnums */ 2320 inline RegionFlags operator^(RegionFlags lhs, RegionFlags rhs) 2321 { return static_cast<RegionFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); } 2322 2323 /** @ingroup gtkmmEnums */ 2324 inline RegionFlags operator~(RegionFlags flags) 2325 { return static_cast<RegionFlags>(~static_cast<unsigned>(flags)); } 2326 2327 /** @ingroup gtkmmEnums */ 2328 inline RegionFlags& operator|=(RegionFlags& lhs, RegionFlags rhs) 2329 { return (lhs = static_cast<RegionFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); } 2330 2331 /** @ingroup gtkmmEnums */ 2332 inline RegionFlags& operator&=(RegionFlags& lhs, RegionFlags rhs) 2333 { return (lhs = static_cast<RegionFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); } 2334 2335 /** @ingroup gtkmmEnums */ 2336 inline RegionFlags& operator^=(RegionFlags& lhs, RegionFlags rhs) 2337 { return (lhs = static_cast<RegionFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); } 2338 2339 } // namespace Gtk 2340 2341 #ifndef DOXYGEN_SHOULD_SKIP_THIS 2342 namespace Glib 2343 { 2344 2345 template <> 2346 class Value<Gtk::RegionFlags> : public Glib::Value_Flags<Gtk::RegionFlags> 2347 { 2348 public: 2349 static GType value_type() G_GNUC_CONST; 2350 }; 2351 2352 } // namespace Glib 2353 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 2354 2355 namespace Gtk 2356 { 2357 2358 /** 2359 * @var JunctionSides JUNCTION_NONE 2360 * No junctions. 2361 * 2362 * @var JunctionSides JUNCTION_CORNER_TOPLEFT 2363 * Element connects on the top-left corner. 2364 * 2365 * @var JunctionSides JUNCTION_CORNER_TOPRIGHT 2366 * Element connects on the top-right corner. 2367 * 2368 * @var JunctionSides JUNCTION_CORNER_BOTTOMLEFT 2369 * Element connects on the bottom-left corner. 2370 * 2371 * @var JunctionSides JUNCTION_CORNER_BOTTOMRIGHT 2372 * Element connects on the bottom-right corner. 2373 * 2374 * @var JunctionSides JUNCTION_TOP 2375 * Element connects on the top side. 2376 * 2377 * @var JunctionSides JUNCTION_BOTTOM 2378 * Element connects on the bottom side. 2379 * 2380 * @var JunctionSides JUNCTION_LEFT 2381 * Element connects on the left side. 2382 * 2383 * @var JunctionSides JUNCTION_RIGHT 2384 * Element connects on the right side. 2385 * 2386 * @enum JunctionSides 2387 * 2388 * Describes how a rendered element connects to adjacent elements. 2389 * 2390 * @ingroup gtkmmEnums 2391 * @par Bitwise operators: 2392 * <tt>%JunctionSides operator|(JunctionSides, JunctionSides)</tt><br> 2393 * <tt>%JunctionSides operator&(JunctionSides, JunctionSides)</tt><br> 2394 * <tt>%JunctionSides operator^(JunctionSides, JunctionSides)</tt><br> 2395 * <tt>%JunctionSides operator~(JunctionSides)</tt><br> 2396 * <tt>%JunctionSides& operator|=(JunctionSides&, JunctionSides)</tt><br> 2397 * <tt>%JunctionSides& operator&=(JunctionSides&, JunctionSides)</tt><br> 2398 * <tt>%JunctionSides& operator^=(JunctionSides&, JunctionSides)</tt><br> 2399 */ 2400 enum JunctionSides 2401 { 2402 JUNCTION_NONE = 0x0, 2403 JUNCTION_CORNER_TOPLEFT = 1 << 0, 2404 JUNCTION_CORNER_TOPRIGHT = 1 << 1, 2405 JUNCTION_CORNER_BOTTOMLEFT = 1 << 2, 2406 JUNCTION_CORNER_BOTTOMRIGHT = 1 << 3, 2407 JUNCTION_TOP = 0x3, 2408 JUNCTION_BOTTOM = 0xC, 2409 JUNCTION_LEFT = 0x5, 2410 JUNCTION_RIGHT = 0xA 2411 }; 2412 2413 /** @ingroup gtkmmEnums */ 2414 inline JunctionSides operator|(JunctionSides lhs, JunctionSides rhs) 2415 { return static_cast<JunctionSides>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); } 2416 2417 /** @ingroup gtkmmEnums */ 2418 inline JunctionSides operator&(JunctionSides lhs, JunctionSides rhs) 2419 { return static_cast<JunctionSides>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); } 2420 2421 /** @ingroup gtkmmEnums */ 2422 inline JunctionSides operator^(JunctionSides lhs, JunctionSides rhs) 2423 { return static_cast<JunctionSides>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); } 2424 2425 /** @ingroup gtkmmEnums */ 2426 inline JunctionSides operator~(JunctionSides flags) 2427 { return static_cast<JunctionSides>(~static_cast<unsigned>(flags)); } 2428 2429 /** @ingroup gtkmmEnums */ 2430 inline JunctionSides& operator|=(JunctionSides& lhs, JunctionSides rhs) 2431 { return (lhs = static_cast<JunctionSides>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); } 2432 2433 /** @ingroup gtkmmEnums */ 2434 inline JunctionSides& operator&=(JunctionSides& lhs, JunctionSides rhs) 2435 { return (lhs = static_cast<JunctionSides>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); } 2436 2437 /** @ingroup gtkmmEnums */ 2438 inline JunctionSides& operator^=(JunctionSides& lhs, JunctionSides rhs) 2439 { return (lhs = static_cast<JunctionSides>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); } 2440 2441 } // namespace Gtk 2442 2443 #ifndef DOXYGEN_SHOULD_SKIP_THIS 2444 namespace Glib 2445 { 2446 2447 template <> 2448 class Value<Gtk::JunctionSides> : public Glib::Value_Flags<Gtk::JunctionSides> 2449 { 2450 public: 2451 static GType value_type() G_GNUC_CONST; 2452 }; 2453 2454 } // namespace Glib 2455 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 2456 2457 namespace Gtk 2458 { 2459 2460 /** 2461 * @var StateFlags STATE_FLAG_NORMAL 2462 * State during normal operation. 2463 * 2464 * @var StateFlags STATE_FLAG_ACTIVE 2465 * Widget is active. 2466 * 2467 * @var StateFlags STATE_FLAG_PRELIGHT 2468 * Widget has a mouse pointer over it. 2469 * 2470 * @var StateFlags STATE_FLAG_SELECTED 2471 * Widget is selected. 2472 * 2473 * @var StateFlags STATE_FLAG_INSENSITIVE 2474 * Widget is insensitive. 2475 * 2476 * @var StateFlags STATE_FLAG_INCONSISTENT 2477 * Widget is inconsistent. 2478 * 2479 * @var StateFlags STATE_FLAG_FOCUSED 2480 * Widget has the keyboard focus. 2481 * 2482 * @var StateFlags STATE_FLAG_BACKDROP 2483 * Widget is in a background toplevel window. 2484 * 2485 * @var StateFlags STATE_FLAG_DIR_LTR 2486 * Widget is in left-to-right text direction. @newin{3,8} 2487 * 2488 * @var StateFlags STATE_FLAG_DIR_RTL 2489 * Widget is in right-to-left text direction. @newin{3,8} 2490 * 2491 * @var StateFlags STATE_FLAG_LINK 2492 * Widget is a link. @newin{3,12} 2493 * 2494 * @var StateFlags STATE_FLAG_VISITED 2495 * The location the widget points to has already been visited. @newin{3,12} 2496 * 2497 * @var StateFlags STATE_FLAG_CHECKED 2498 * Widget is checked. @newin{3,14} 2499 * 2500 * @var StateFlags STATE_FLAG_DROP_ACTIVE 2501 * Widget is highlighted as a drop target for DND. @newin{3,20} 2502 * 2503 * @enum StateFlags 2504 * 2505 * Describes a widget state. Widget states are used to match the widget 2506 * against CSS pseudo-classes. Note that GTK extends the regular CSS 2507 * classes and sometimes uses different names. 2508 * 2509 * @ingroup gtkmmEnums 2510 * @par Bitwise operators: 2511 * <tt>%StateFlags operator|(StateFlags, StateFlags)</tt><br> 2512 * <tt>%StateFlags operator&(StateFlags, StateFlags)</tt><br> 2513 * <tt>%StateFlags operator^(StateFlags, StateFlags)</tt><br> 2514 * <tt>%StateFlags operator~(StateFlags)</tt><br> 2515 * <tt>%StateFlags& operator|=(StateFlags&, StateFlags)</tt><br> 2516 * <tt>%StateFlags& operator&=(StateFlags&, StateFlags)</tt><br> 2517 * <tt>%StateFlags& operator^=(StateFlags&, StateFlags)</tt><br> 2518 */ 2519 enum StateFlags 2520 { 2521 STATE_FLAG_NORMAL = 0x0, 2522 STATE_FLAG_ACTIVE = 1 << 0, 2523 STATE_FLAG_PRELIGHT = 1 << 1, 2524 STATE_FLAG_SELECTED = 1 << 2, 2525 STATE_FLAG_INSENSITIVE = 1 << 3, 2526 STATE_FLAG_INCONSISTENT = 1 << 4, 2527 STATE_FLAG_FOCUSED = 1 << 5, 2528 STATE_FLAG_BACKDROP = 1 << 6, 2529 STATE_FLAG_DIR_LTR = 1 << 7, 2530 STATE_FLAG_DIR_RTL = 1 << 8, 2531 STATE_FLAG_LINK = 1 << 9, 2532 STATE_FLAG_VISITED = 1 << 10, 2533 STATE_FLAG_CHECKED = 1 << 11, 2534 STATE_FLAG_DROP_ACTIVE = 1 << 12 2535 }; 2536 2537 /** @ingroup gtkmmEnums */ 2538 inline StateFlags operator|(StateFlags lhs, StateFlags rhs) 2539 { return static_cast<StateFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); } 2540 2541 /** @ingroup gtkmmEnums */ 2542 inline StateFlags operator&(StateFlags lhs, StateFlags rhs) 2543 { return static_cast<StateFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); } 2544 2545 /** @ingroup gtkmmEnums */ 2546 inline StateFlags operator^(StateFlags lhs, StateFlags rhs) 2547 { return static_cast<StateFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); } 2548 2549 /** @ingroup gtkmmEnums */ 2550 inline StateFlags operator~(StateFlags flags) 2551 { return static_cast<StateFlags>(~static_cast<unsigned>(flags)); } 2552 2553 /** @ingroup gtkmmEnums */ 2554 inline StateFlags& operator|=(StateFlags& lhs, StateFlags rhs) 2555 { return (lhs = static_cast<StateFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); } 2556 2557 /** @ingroup gtkmmEnums */ 2558 inline StateFlags& operator&=(StateFlags& lhs, StateFlags rhs) 2559 { return (lhs = static_cast<StateFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); } 2560 2561 /** @ingroup gtkmmEnums */ 2562 inline StateFlags& operator^=(StateFlags& lhs, StateFlags rhs) 2563 { return (lhs = static_cast<StateFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); } 2564 2565 } // namespace Gtk 2566 2567 #ifndef DOXYGEN_SHOULD_SKIP_THIS 2568 namespace Glib 2569 { 2570 2571 template <> 2572 class Value<Gtk::StateFlags> : public Glib::Value_Flags<Gtk::StateFlags> 2573 { 2574 public: 2575 static GType value_type() G_GNUC_CONST; 2576 }; 2577 2578 } // namespace Glib 2579 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 2580 2581 namespace Gtk 2582 { 2583 2584 /** 2585 * @var InputPurpose INPUT_PURPOSE_FREE_FORM 2586 * Allow any character. 2587 * 2588 * @var InputPurpose INPUT_PURPOSE_ALPHA 2589 * Allow only alphabetic characters. 2590 * 2591 * @var InputPurpose INPUT_PURPOSE_DIGITS 2592 * Allow only digits. 2593 * 2594 * @var InputPurpose INPUT_PURPOSE_NUMBER 2595 * Edited field expects numbers. 2596 * 2597 * @var InputPurpose INPUT_PURPOSE_PHONE 2598 * Edited field expects phone number. 2599 * 2600 * @var InputPurpose INPUT_PURPOSE_URL 2601 * Edited field expects URL. 2602 * 2603 * @var InputPurpose INPUT_PURPOSE_EMAIL 2604 * Edited field expects email address. 2605 * 2606 * @var InputPurpose INPUT_PURPOSE_NAME 2607 * Edited field expects the name of a person. 2608 * 2609 * @var InputPurpose INPUT_PURPOSE_PASSWORD 2610 * Like @a GTK_INPUT_PURPOSE_FREE_FORM, but characters are hidden. 2611 * 2612 * @var InputPurpose INPUT_PURPOSE_PIN 2613 * Like @a GTK_INPUT_PURPOSE_DIGITS, but characters are hidden. 2614 * 2615 * @enum InputPurpose 2616 * 2617 * Describes primary purpose of the input widget. This information is 2618 * useful for on-screen keyboards and similar input methods to decide 2619 * which keys should be presented to the user. 2620 * 2621 * Note that the purpose is not meant to impose a totally strict rule 2622 * about allowed characters, and does not replace input validation. 2623 * It is fine for an on-screen keyboard to let the user override the 2624 * character set restriction that is expressed by the purpose. The 2625 * application is expected to validate the entry contents, even if 2626 * it specified a purpose. 2627 * 2628 * The difference between @a GTK_INPUT_PURPOSE_DIGITS and 2629 * @a GTK_INPUT_PURPOSE_NUMBER is that the former accepts only digits 2630 * while the latter also some punctuation (like commas or points, plus, 2631 * minus) and “e” or “E” as in 3.14E+000. 2632 * 2633 * This enumeration may be extended in the future; input methods should 2634 * interpret unknown values as “free form”. 2635 * 2636 * @newin{3,6} 2637 * 2638 * @ingroup gtkmmEnums 2639 */ 2640 enum InputPurpose 2641 { 2642 INPUT_PURPOSE_FREE_FORM, 2643 INPUT_PURPOSE_ALPHA, 2644 INPUT_PURPOSE_DIGITS, 2645 INPUT_PURPOSE_NUMBER, 2646 INPUT_PURPOSE_PHONE, 2647 INPUT_PURPOSE_URL, 2648 INPUT_PURPOSE_EMAIL, 2649 INPUT_PURPOSE_NAME, 2650 INPUT_PURPOSE_PASSWORD, 2651 INPUT_PURPOSE_PIN 2652 }; 2653 2654 } // namespace Gtk 2655 2656 #ifndef DOXYGEN_SHOULD_SKIP_THIS 2657 namespace Glib 2658 { 2659 2660 template <> 2661 class Value<Gtk::InputPurpose> : public Glib::Value_Enum<Gtk::InputPurpose> 2662 { 2663 public: 2664 static GType value_type() G_GNUC_CONST; 2665 }; 2666 2667 } // namespace Glib 2668 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 2669 2670 namespace Gtk 2671 { 2672 2673 /** 2674 * @var InputHints INPUT_HINT_NONE 2675 * No special behaviour suggested. 2676 * 2677 * @var InputHints INPUT_HINT_SPELLCHECK 2678 * Suggest checking for typos. 2679 * 2680 * @var InputHints INPUT_HINT_NO_SPELLCHECK 2681 * Suggest not checking for typos. 2682 * 2683 * @var InputHints INPUT_HINT_WORD_COMPLETION 2684 * Suggest word completion. 2685 * 2686 * @var InputHints INPUT_HINT_LOWERCASE 2687 * Suggest to convert all text to lowercase. 2688 * 2689 * @var InputHints INPUT_HINT_UPPERCASE_CHARS 2690 * Suggest to capitalize all text. 2691 * 2692 * @var InputHints INPUT_HINT_UPPERCASE_WORDS 2693 * Suggest to capitalize the first 2694 * character of each word. 2695 * 2696 * @var InputHints INPUT_HINT_UPPERCASE_SENTENCES 2697 * Suggest to capitalize the 2698 * first word of each sentence. 2699 * 2700 * @var InputHints INPUT_HINT_INHIBIT_OSK 2701 * Suggest to not show an onscreen keyboard 2702 * (e.g for a calculator that already has all the keys). 2703 * 2704 * @var InputHints INPUT_HINT_VERTICAL_WRITING 2705 * The text is vertical. @newin{3,18} 2706 * 2707 * @var InputHints INPUT_HINT_EMOJI 2708 * Suggest offering Emoji support. @newin{3,22,20} 2709 * 2710 * @var InputHints INPUT_HINT_NO_EMOJI 2711 * Suggest not offering Emoji support. @newin{3,22,20} 2712 * 2713 * @enum InputHints 2714 * 2715 * Describes hints that might be taken into account by input methods 2716 * or applications. Note that input methods may already tailor their 2717 * behaviour according to the Gtk::InputPurpose of the entry. 2718 * 2719 * Some common sense is expected when using these flags - mixing 2720 * @a GTK_INPUT_HINT_LOWERCASE with any of the uppercase hints makes no sense. 2721 * 2722 * This enumeration may be extended in the future; input methods should 2723 * ignore unknown values. 2724 * 2725 * @newin{3,6} 2726 * 2727 * @ingroup gtkmmEnums 2728 * @par Bitwise operators: 2729 * <tt>%InputHints operator|(InputHints, InputHints)</tt><br> 2730 * <tt>%InputHints operator&(InputHints, InputHints)</tt><br> 2731 * <tt>%InputHints operator^(InputHints, InputHints)</tt><br> 2732 * <tt>%InputHints operator~(InputHints)</tt><br> 2733 * <tt>%InputHints& operator|=(InputHints&, InputHints)</tt><br> 2734 * <tt>%InputHints& operator&=(InputHints&, InputHints)</tt><br> 2735 * <tt>%InputHints& operator^=(InputHints&, InputHints)</tt><br> 2736 */ 2737 enum InputHints 2738 { 2739 INPUT_HINT_NONE = 0x0, 2740 INPUT_HINT_SPELLCHECK = 1 << 0, 2741 INPUT_HINT_NO_SPELLCHECK = 1 << 1, 2742 INPUT_HINT_WORD_COMPLETION = 1 << 2, 2743 INPUT_HINT_LOWERCASE = 1 << 3, 2744 INPUT_HINT_UPPERCASE_CHARS = 1 << 4, 2745 INPUT_HINT_UPPERCASE_WORDS = 1 << 5, 2746 INPUT_HINT_UPPERCASE_SENTENCES = 1 << 6, 2747 INPUT_HINT_INHIBIT_OSK = 1 << 7, 2748 INPUT_HINT_VERTICAL_WRITING = 1 << 8, 2749 INPUT_HINT_EMOJI = 1 << 9, 2750 INPUT_HINT_NO_EMOJI = 1 << 10 2751 }; 2752 2753 /** @ingroup gtkmmEnums */ 2754 inline InputHints operator|(InputHints lhs, InputHints rhs) 2755 { return static_cast<InputHints>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); } 2756 2757 /** @ingroup gtkmmEnums */ 2758 inline InputHints operator&(InputHints lhs, InputHints rhs) 2759 { return static_cast<InputHints>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); } 2760 2761 /** @ingroup gtkmmEnums */ 2762 inline InputHints operator^(InputHints lhs, InputHints rhs) 2763 { return static_cast<InputHints>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); } 2764 2765 /** @ingroup gtkmmEnums */ 2766 inline InputHints operator~(InputHints flags) 2767 { return static_cast<InputHints>(~static_cast<unsigned>(flags)); } 2768 2769 /** @ingroup gtkmmEnums */ 2770 inline InputHints& operator|=(InputHints& lhs, InputHints rhs) 2771 { return (lhs = static_cast<InputHints>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); } 2772 2773 /** @ingroup gtkmmEnums */ 2774 inline InputHints& operator&=(InputHints& lhs, InputHints rhs) 2775 { return (lhs = static_cast<InputHints>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); } 2776 2777 /** @ingroup gtkmmEnums */ 2778 inline InputHints& operator^=(InputHints& lhs, InputHints rhs) 2779 { return (lhs = static_cast<InputHints>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); } 2780 2781 } // namespace Gtk 2782 2783 #ifndef DOXYGEN_SHOULD_SKIP_THIS 2784 namespace Glib 2785 { 2786 2787 template <> 2788 class Value<Gtk::InputHints> : public Glib::Value_Flags<Gtk::InputHints> 2789 { 2790 public: 2791 static GType value_type() G_GNUC_CONST; 2792 }; 2793 2794 } // namespace Glib 2795 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 2796 2797 namespace Gtk 2798 { 2799 2800 /** 2801 * @var BaselinePosition BASELINE_POSITION_TOP 2802 * Align the baseline at the top. 2803 * 2804 * @var BaselinePosition BASELINE_POSITION_CENTER 2805 * Center the baseline. 2806 * 2807 * @var BaselinePosition BASELINE_POSITION_BOTTOM 2808 * Align the baseline at the bottom. 2809 * 2810 * @enum BaselinePosition 2811 * 2812 * Whenever a container has some form of natural row it may align 2813 * children in that row along a common typographical baseline. If 2814 * the amount of verical space in the row is taller than the total 2815 * requested height of the baseline-aligned children then it can use a 2816 * Gtk::BaselinePosition to select where to put the baseline inside the 2817 * extra availible space. 2818 * 2819 * @newin{3,10} 2820 * 2821 * @ingroup gtkmmEnums 2822 */ 2823 enum BaselinePosition 2824 { 2825 BASELINE_POSITION_TOP, 2826 BASELINE_POSITION_CENTER, 2827 BASELINE_POSITION_BOTTOM 2828 }; 2829 2830 } // namespace Gtk 2831 2832 #ifndef DOXYGEN_SHOULD_SKIP_THIS 2833 namespace Glib 2834 { 2835 2836 template <> 2837 class Value<Gtk::BaselinePosition> : public Glib::Value_Enum<Gtk::BaselinePosition> 2838 { 2839 public: 2840 static GType value_type() G_GNUC_CONST; 2841 }; 2842 2843 } // namespace Glib 2844 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 2845 2846 namespace Gtk 2847 { 2848 2849 2850 /* We use a class to implement the GtkIconSize enum, because you can register 2851 * new "enum" values. The strict type rules of C++ don't allow using an enum 2852 * like that. Gtk::BuiltinIconSize is the actual GtkIconSize wrapper enum. 2853 */ 2854 2855 #ifndef DOXYGEN_SHOULD_SKIP_THIS 2856 class Settings; 2857 #endif //DOXYGEN_SHOULD_SKIP_THIS 2858 2859 /** 2860 * Represents registered icon sizes. 2861 * You can also use a Gtk::BuiltinIconSize instead of an IconSize. 2862 */ 2863 class IconSize 2864 { 2865 private: 2866 int size_; 2867 2868 public: IconSize()2869 IconSize() : size_ (0) {} IconSize(BuiltinIconSize size)2870 IconSize(BuiltinIconSize size) : size_ (size) {} 2871 2872 // Behave like an ordinary enum. IconSize(int size)2873 explicit IconSize(int size) : size_ (size) {} 2874 operator int() const { return size_; } 2875 2876 /** Obtains the pixel size of a semantic icon size, possibly modified by user preferences for the default Gtk::Settings. 2877 * Normally size would be Gtk::ICON_SIZE_MENU, Gtk::ICON_SIZE_BUTTON, etc. 2878 * This function isn't normally needed because Gtk::Widget::render_icon() is the usual way to get an icon for 2879 * rendering - then just look at the size of the rendered pixbuf. The rendered pixbuf may not even correspond 2880 * to the width/height returned by IconSize::lookup(), because themes are free to render the pixbuf however they 2881 * like, including changing the usual size. 2882 * 2883 * @param size An icon size. 2884 * @param width Location to store icon width. 2885 * @param height Location to store icon height. 2886 * @result true if size was a valid size. 2887 */ 2888 static bool lookup(IconSize size, int& width, int& height); 2889 2890 #ifndef GTKMM_DISABLE_DEPRECATED 2891 /** Obtains the pixel size of a semantic icon size, possibly modified by user preferences for a particular 2892 * Gtk::Settings. Normally size would be Gtk::ICON_SIZE_MENU, Gtk::ICON_SIZE_BUTTON, etc. 2893 * This function isn't normally needed because Gtk::Widget::render_icon() is the usual way to get an icon for 2894 * rendering - then just look at the size of the rendered pixbuf. The rendered pixbuf may not even correspond 2895 * to the width/height returned by IconSize::lookup(), because themes are free to render the pixbuf however they 2896 * like, including changing the usual size. 2897 * 2898 * @param size An icon size. 2899 * @param width Location to store icon width. 2900 * @param height Location to store icon height. 2901 * @param settings A Gtk::Settings object, used to determine which set of user preferences to used. 2902 * @result true if size was a valid size. 2903 * 2904 * @deprecated Use IconSize::lookup() without the @a settings parameter instead. 2905 * @newin{2,14} 2906 */ 2907 static bool lookup(IconSize size, int& width, int& height, const Glib::RefPtr<Gtk::Settings>& settings); 2908 #endif //GTKMM_DISABLE_DEPRECATED 2909 2910 #ifndef GTKMM_DISABLE_DEPRECATED 2911 /** Registers a new icon size, along the same lines as ICON_SIZE_MENU, etc. Returns the integer value for the size. 2912 * 2913 * @param name Name of the icon size. 2914 * @param width The icon width. 2915 * @param height The icon height. 2916 * @result Integer value representing the size. 2917 * @deprecated Use Gtk::IconTheme instead. 2918 */ 2919 static IconSize register_new(const Glib::ustring& name, int width, int height); 2920 #endif //GTKMM_DISABLE_DEPRECATED 2921 2922 #ifndef GTKMM_DISABLE_DEPRECATED 2923 /** Registers @a alias as another name for @a target so calling from_name() with @a alias as argument will return @a target. 2924 * 2925 * @param alias An alias for target. 2926 * @param target An existing icon size. 2927 * @deprecated Use Gtk::IconTheme instead. 2928 */ 2929 static void register_alias(const Glib::ustring& alias, IconSize target); 2930 #endif //GTKMM_DISABLE_DEPRECATED 2931 2932 #ifndef GTKMM_DISABLE_DEPRECATED 2933 /** Looks up the icon size associated with @a name. 2934 * 2935 * @param name the name to look up. 2936 * @result The icon size with the given name. 2937 * @deprecated Use Gtk::IconTheme instead. 2938 */ 2939 static IconSize from_name(const Glib::ustring& name); 2940 #endif //GTKMM_DISABLE_DEPRECATED 2941 2942 #ifndef GTKMM_DISABLE_DEPRECATED 2943 /** Gets the canonical name of the given icon size. 2944 * 2945 * @param size size AnIconSize. 2946 * @result The name of the given icon size. 2947 * @deprecated Use Gtk::IconTheme instead. 2948 */ 2949 static Glib::ustring get_name(IconSize size); 2950 #endif //GTKMM_DISABLE_DEPRECATED 2951 }; 2952 2953 2954 #ifndef DOXYGEN_SHOULD_SKIP_THIS 2955 struct IconSizeTraits 2956 { 2957 typedef Gtk::IconSize CppType; 2958 typedef GtkIconSize CType; 2959 typedef GtkIconSize CTypeNonConst; 2960 to_c_typeIconSizeTraits2961 static CType to_c_type (CType c_obj) { return c_obj; } release_c_typeIconSizeTraits2962 static void release_c_type (CType) {} to_c_typeIconSizeTraits2963 static CType to_c_type (const CppType& cpp_obj) { int value (cpp_obj); return static_cast<CType> (value); } to_cpp_typeIconSizeTraits2964 static CppType to_cpp_type (CType c_obj) { return CppType (c_obj); } 2965 }; 2966 #endif //DOXYGEN_SHOULD_SKIP_THIS 2967 2968 } // namespace Gtk 2969 2970 2971 #ifndef DOXYGEN_SHOULD_SKIP_THIS 2972 namespace Glib 2973 { 2974 2975 template <> 2976 class Value<Gtk::IconSize> : public Glib::Value_Enum<Gtk::IconSize> 2977 { 2978 public: 2979 static GType value_type() G_GNUC_CONST; 2980 }; 2981 2982 } // namespace Glib 2983 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 2984 2985 namespace Gtk 2986 { 2987 2988 #ifndef DOXYGEN_SHOULD_SKIP_THIS 2989 //We need this because we can't just use floats for enum value. 2990 float _gtkmm_align_float_from_enum(Align value); 2991 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 2992 2993 } //namespace Gtk 2994 2995 2996 #endif /* _GTKMM_ENUMS_H */ 2997 2998