Pileus Git - ~andy/gtk/blob - gtk/gtkenums.h

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
  28 #error "Only <gtk/gtk.h> can be included directly."
  29 #endif
  30
  31 #ifndef __GTK_ENUMS_H__
  32 #define __GTK_ENUMS_H__
  33
  34 #include <glib-object.h>
  35
  36
  37 /**
  38  * SECTION:gtkenum
  39  * @Short_description: Public enumerated types used throughout GTK+
  40  * @Title: Standard Enumerations
  41  */
  42
  43
  44 G_BEGIN_DECLS
  45
  46 /**
  47  * GtkAlign:
  48  * @GTK_ALIGN_FILL: stretch to fill all space if possible, center if
  49  *     no meaningful way to stretch
  50  * @GTK_ALIGN_START: snap to left or top side, leaving space on right
  51  *     or bottom
  52  * @GTK_ALIGN_END: snap to right or bottom side, leaving space on left
  53  *     or top
  54  * @GTK_ALIGN_CENTER: center natural width of widget inside the
  55  *     allocation
  56  *
  57  * Controls how a widget deals with extra space in a single (x or y)
  58  * dimension.
  59  *
  60  * Alignment only matters if the widget receives a "too large" allocation,
  61  * for example if you packed the widget with the #GtkWidget:expand
  62  * flag inside a #GtkBox, then the widget might get extra space.  If
  63  * you have for example a 16x16 icon inside a 32x32 space, the icon
  64  * could be scaled and stretched, it could be centered, or it could be
  65  * positioned to one side of the space.
  66  */
  67 typedef enum
  68 {
  69   GTK_ALIGN_FILL,
  70   GTK_ALIGN_START,
  71   GTK_ALIGN_END,
  72   GTK_ALIGN_CENTER
  73 } GtkAlign;
  74
  75
  76 /**
  77  * GtkArrowPlacement:
  78  * @GTK_ARROWS_BOTH: Place one arrow on each end of the menu.
  79  * @GTK_ARROWS_START: Place both arrows at the top of the menu.
  80  * @GTK_ARROWS_END: Place both arrows at the bottom of the menu.
  81  *
  82  * Used to specify the placement of scroll arrows in scrolling menus.
  83  */
  84 typedef enum
  85 {
  86   GTK_ARROWS_BOTH,
  87   GTK_ARROWS_START,
  88   GTK_ARROWS_END
  89 } GtkArrowPlacement;
  90
  91 /**
  92  * GtkArrowType
  93  * @GTK_ARROW_UP: Represents an upward pointing arrow.
  94  * @GTK_ARROW_DOWN: Represents a downward pointing arrow.
  95  * @GTK_ARROW_LEFT: Represents a left pointing arrow.
  96  * @GTK_ARROW_RIGHT: Represents a right pointing arrow.
  97  * @GTK_ARROW_NONE: No arrow. Since 2.10.
  98  *
  99  * Used to indicate the direction in which a #GtkArrow should point.
 100  */
 101 typedef enum
 102 {
 103   GTK_ARROW_UP,
 104   GTK_ARROW_DOWN,
 105   GTK_ARROW_LEFT,
 106   GTK_ARROW_RIGHT,
 107   GTK_ARROW_NONE
 108 } GtkArrowType;
 109
 110 /**
 111  * GtkAttachOptions:
 112  * @GTK_EXPAND: the widget should expand to take up any extra space in its
 113  * container that has been allocated.
 114  * @GTK_SHRINK: the widget should shrink as and when possible.
 115  * @GTK_FILL: the widget should fill the space allocated to it.
 116  *
 117  * Denotes the expansion properties that a widget will have when it (or its
 118  * parent) is resized.
 119  */
 120 typedef enum
 121 {
 122   GTK_EXPAND = 1 << 0,
 123   GTK_SHRINK = 1 << 1,
 124   GTK_FILL   = 1 << 2
 125 } GtkAttachOptions;
 126
 127 /**
 128  * GtkButtonBoxStyle:
 129  * @GTK_BUTTONBOX_DEFAULT_STYLE: Default packing.
 130  * @GTK_BUTTONBOX_SPREAD: Buttons are evenly spread across the box.
 131  * @GTK_BUTTONBOX_EDGE: Buttons are placed at the edges of the box.
 132  * @GTK_BUTTONBOX_START: Buttons are grouped towards the start of the box,
 133  *   (on the left for a HBox, or the top for a VBox).
 134  * @GTK_BUTTONBOX_END: Buttons are grouped towards the end of the box,
 135  *   (on the right for a HBox, or the bottom for a VBox).
 136  * @GTK_BUTTONBOX_CENTER: Buttons are centered in the box. Since 2.12.
 137  *
 138  * Used to dictate the style that a #GtkButtonBox uses to layout the buttons it
 139  * contains. (See also: #GtkVButtonBox and #GtkHButtonBox).
 140  */
 141 typedef enum
 142 {
 143   GTK_BUTTONBOX_SPREAD = 1,
 144   GTK_BUTTONBOX_EDGE,
 145   GTK_BUTTONBOX_START,
 146   GTK_BUTTONBOX_END,
 147   GTK_BUTTONBOX_CENTER
 148 } GtkButtonBoxStyle;
 149
 150
 151 typedef enum
 152 {
 153   GTK_DELETE_CHARS,
 154   GTK_DELETE_WORD_ENDS,           /* delete only the portion of the word to the
 155                                    * left/right of cursor if we're in the middle
 156                                    * of a word */
 157   GTK_DELETE_WORDS,
 158   GTK_DELETE_DISPLAY_LINES,
 159   GTK_DELETE_DISPLAY_LINE_ENDS,
 160   GTK_DELETE_PARAGRAPH_ENDS,      /* like C-k in Emacs (or its reverse) */
 161   GTK_DELETE_PARAGRAPHS,          /* C-k in pico, kill whole line */
 162   GTK_DELETE_WHITESPACE           /* M-\ in Emacs */
 163 } GtkDeleteType;
 164
 165 /* Focus movement types */
 166 typedef enum
 167 {
 168   GTK_DIR_TAB_FORWARD,
 169   GTK_DIR_TAB_BACKWARD,
 170   GTK_DIR_UP,
 171   GTK_DIR_DOWN,
 172   GTK_DIR_LEFT,
 173   GTK_DIR_RIGHT
 174 } GtkDirectionType;
 175
 176 /**
 177  * GtkExpanderStyle:
 178  * @GTK_EXPANDER_COLLAPSED: The style used for a collapsed subtree.
 179  * @GTK_EXPANDER_SEMI_COLLAPSED: Intermediate style used during animation.
 180  * @GTK_EXPANDER_SEMI_EXPANDED: Intermediate style used during animation.
 181  * @GTK_EXPANDER_EXPANDED: The style used for an expanded subtree.
 182  *
 183  * Used to specify the style of the expanders drawn by a #GtkTreeView.
 184  */
 185 typedef enum
 186 {
 187   GTK_EXPANDER_COLLAPSED,
 188   GTK_EXPANDER_SEMI_COLLAPSED,
 189   GTK_EXPANDER_SEMI_EXPANDED,
 190   GTK_EXPANDER_EXPANDED
 191 } GtkExpanderStyle;
 192
 193 /* Built-in stock icon sizes */
 194 typedef enum
 195 {
 196   GTK_ICON_SIZE_INVALID,
 197   GTK_ICON_SIZE_MENU,
 198   GTK_ICON_SIZE_SMALL_TOOLBAR,
 199   GTK_ICON_SIZE_LARGE_TOOLBAR,
 200   GTK_ICON_SIZE_BUTTON,
 201   GTK_ICON_SIZE_DND,
 202   GTK_ICON_SIZE_DIALOG
 203 } GtkIconSize;
 204
 205 /**
 206  * GtkSensitivityType:
 207  * @GTK_SENSITIVITY_AUTO: The arrow is made insensitive if the
 208  *   thumb is at the end
 209  * @GTK_SENSITIVITY_ON: The arrow is always sensitive
 210  * @GTK_SENSITIVITY_OFF: The arrow is always insensitive
 211  *
 212  * Determines how GTK+ handles the sensitivity of stepper arrows
 213  * at the end of range widgets.
 214  */
 215 typedef enum
 216 {
 217   GTK_SENSITIVITY_AUTO,
 218   GTK_SENSITIVITY_ON,
 219   GTK_SENSITIVITY_OFF
 220 } GtkSensitivityType;
 221
 222 /* Reading directions for text */
 223 typedef enum
 224 {
 225   GTK_TEXT_DIR_NONE,
 226   GTK_TEXT_DIR_LTR,
 227   GTK_TEXT_DIR_RTL
 228 } GtkTextDirection;
 229
 230 /**
 231  * GtkJustification:
 232  * @GTK_JUSTIFY_LEFT: The text is placed at the left edge of the label.
 233  * @GTK_JUSTIFY_RIGHT: The text is placed at the right edge of the label.
 234  * @GTK_JUSTIFY_CENTER: The text is placed in the center of the label.
 235  * @GTK_JUSTIFY_FILL: The text is placed is distributed across the label.
 236  *
 237  * Used for justifying the text inside a #GtkLabel widget. (See also
 238  * #GtkAlignment).
 239  */
 240 typedef enum
 241 {
 242   GTK_JUSTIFY_LEFT,
 243   GTK_JUSTIFY_RIGHT,
 244   GTK_JUSTIFY_CENTER,
 245   GTK_JUSTIFY_FILL
 246 } GtkJustification;
 247
 248 /* Menu keyboard movement types */
 249 typedef enum
 250 {
 251   GTK_MENU_DIR_PARENT,
 252   GTK_MENU_DIR_CHILD,
 253   GTK_MENU_DIR_NEXT,
 254   GTK_MENU_DIR_PREV
 255 } GtkMenuDirectionType;
 256
 257 /**
 258  * GtkMessageType:
 259  * @GTK_MESSAGE_INFO: Informational message
 260  * @GTK_MESSAGE_WARNING: Nonfatal warning message
 261  * @GTK_MESSAGE_QUESTION: Question requiring a choice
 262  * @GTK_MESSAGE_ERROR: Fatal error message
 263  * @GTK_MESSAGE_OTHER: None of the above, doesn't get an icon
 264  *
 265  * The type of message being displayed in the dialog.
 266  */
 267 typedef enum
 268 {
 269   GTK_MESSAGE_INFO,
 270   GTK_MESSAGE_WARNING,
 271   GTK_MESSAGE_QUESTION,
 272   GTK_MESSAGE_ERROR,
 273   GTK_MESSAGE_OTHER
 274 } GtkMessageType;
 275
 276 /**
 277  * GtkMovementStep:
 278  * @GTK_MOVEMENT_LOGICAL_POSITIONS: Move forward or back by graphemes
 279  * @GTK_MOVEMENT_VISUAL_POSITIONS:  Move left or right by graphemes
 280  * @GTK_MOVEMENT_WORDS:             Move forward or back by words
 281  * @GTK_MOVEMENT_DISPLAY_LINES:     Move up or down lines (wrapped lines)
 282  * @GTK_MOVEMENT_DISPLAY_LINE_ENDS: Move to either end of a line
 283  * @GTK_MOVEMENT_PARAGRAPHS:        Move up or down paragraphs (newline-ended lines)
 284  * @GTK_MOVEMENT_PARAGRAPH_ENDS:    Move to either end of a paragraph
 285  * @GTK_MOVEMENT_PAGES:             Move by pages
 286  * @GTK_MOVEMENT_BUFFER_ENDS:       Move to ends of the buffer
 287  * @GTK_MOVEMENT_HORIZONTAL_PAGES:  Move horizontally by pages
 288  */
 289 typedef enum
 290 {
 291   GTK_MOVEMENT_LOGICAL_POSITIONS,
 292   GTK_MOVEMENT_VISUAL_POSITIONS,
 293   GTK_MOVEMENT_WORDS,
 294   GTK_MOVEMENT_DISPLAY_LINES,
 295   GTK_MOVEMENT_DISPLAY_LINE_ENDS,
 296   GTK_MOVEMENT_PARAGRAPHS,
 297   GTK_MOVEMENT_PARAGRAPH_ENDS,
 298   GTK_MOVEMENT_PAGES,
 299   GTK_MOVEMENT_BUFFER_ENDS,
 300   GTK_MOVEMENT_HORIZONTAL_PAGES
 301 } GtkMovementStep;
 302
 303 typedef enum
 304 {
 305   GTK_SCROLL_STEPS,
 306   GTK_SCROLL_PAGES,
 307   GTK_SCROLL_ENDS,
 308   GTK_SCROLL_HORIZONTAL_STEPS,
 309   GTK_SCROLL_HORIZONTAL_PAGES,
 310   GTK_SCROLL_HORIZONTAL_ENDS
 311 } GtkScrollStep;
 312
 313 /**
 314  * GtkOrientation:
 315  * @GTK_ORIENTATION_HORIZONTAL: The widget is in horizontal orientation.
 316  * @GTK_ORIENTATION_VERTICAL: The widget is in vertical orientation.
 317  *
 318  * Represents the orientation of widgets which can be switched between horizontal
 319  * and vertical orientation on the fly, like #GtkToolbar.
 320  */
 321 typedef enum
 322 {
 323   GTK_ORIENTATION_HORIZONTAL,
 324   GTK_ORIENTATION_VERTICAL
 325 } GtkOrientation;
 326
 327 /**
 328  * GtkCornerType:
 329  * @GTK_CORNER_TOP_LEFT: Place the scrollbars on the right and bottom of the
 330  *  widget (default behaviour).
 331  * @GTK_CORNER_BOTTOM_LEFT: Place the scrollbars on the top and right of the
 332  *  widget.
 333  * @GTK_CORNER_TOP_RIGHT: Place the scrollbars on the left and bottom of the
 334  *  widget.
 335  * @GTK_CORNER_BOTTOM_RIGHT: Place the scrollbars on the top and left of the
 336  *  widget.
 337  *
 338  * Specifies which corner a child widget should be placed in when packed into
 339  * a #GtkScrolledWindow. This is effectively the opposite of where the scroll
 340  * bars are placed.
 341  */
 342 typedef enum
 343 {
 344   GTK_CORNER_TOP_LEFT,
 345   GTK_CORNER_BOTTOM_LEFT,
 346   GTK_CORNER_TOP_RIGHT,
 347   GTK_CORNER_BOTTOM_RIGHT
 348 } GtkCornerType;
 349
 350 /**
 351  * GtkPackType:
 352  * @GTK_PACK_START: The child is packed into the start of the box
 353  * @GTK_PACK_END: The child is packed into the end of the box
 354  *
 355  * Represents the packing location #GtkBox children. (See: #GtkVBox,
 356  * #GtkHBox, and #GtkButtonBox).
 357  */
 358 typedef enum
 359 {
 360   GTK_PACK_START,
 361   GTK_PACK_END
 362 } GtkPackType;
 363
 364 /* priorities for path lookups */
 365 typedef enum
 366 {
 367   GTK_PATH_PRIO_LOWEST      = 0,
 368   GTK_PATH_PRIO_GTK         = 4,
 369   GTK_PATH_PRIO_APPLICATION = 8,
 370   GTK_PATH_PRIO_THEME       = 10,
 371   GTK_PATH_PRIO_RC          = 12,
 372   GTK_PATH_PRIO_HIGHEST     = 15
 373 } GtkPathPriorityType;
 374 #define GTK_PATH_PRIO_MASK 0x0f
 375
 376 /* widget path types */
 377 typedef enum
 378 {
 379   GTK_PATH_WIDGET,
 380   GTK_PATH_WIDGET_CLASS,
 381   GTK_PATH_CLASS
 382 } GtkPathType;
 383
 384 /**
 385  * GtkPolicyType:
 386  * @GTK_POLICY_ALWAYS: The scrollbar is always visible.
 387  * @GTK_POLICY_AUTOMATIC: The scrollbar will appear and disappear as necessary. For example,
 388  *  when all of a #GtkCList can not be seen.
 389  * @GTK_POLICY_NEVER: The scrollbar will never appear.
 390  *
 391  * Determines when a scroll bar will be visible.
 392  */
 393 typedef enum
 394 {
 395   GTK_POLICY_ALWAYS,
 396   GTK_POLICY_AUTOMATIC,
 397   GTK_POLICY_NEVER
 398 } GtkPolicyType;
 399
 400 /**
 401  * GtkPositionType:
 402  * @GTK_POS_LEFT: The feature is at the left edge.
 403  * @GTK_POS_RIGHT: The feature is at the right edge.
 404  * @GTK_POS_TOP: The feature is at the top edge.
 405  * @GTK_POS_BOTTOM: The feature is at the bottom edge.
 406  *
 407  * Describes which edge of a widget a certain feature is positioned at, e.g. the
 408  * tabs of a #GtkNotebook, the handle of a #GtkHandleBox or the label of a
 409  * #GtkScale.
 410  */
 411 typedef enum
 412 {
 413   GTK_POS_LEFT,
 414   GTK_POS_RIGHT,
 415   GTK_POS_TOP,
 416   GTK_POS_BOTTOM
 417 } GtkPositionType;
 418
 419 /**
 420  * GtkReliefStyle:
 421  * @GTK_RELIEF_NORMAL: Draw a normal relief.
 422  * @GTK_RELIEF_HALF: A half relief.
 423  * @GTK_RELIEF_NONE: No relief.
 424  *
 425  * Indicated the relief to be drawn around a #GtkButton.
 426  */
 427 typedef enum
 428 {
 429   GTK_RELIEF_NORMAL,
 430   GTK_RELIEF_HALF,
 431   GTK_RELIEF_NONE
 432 } GtkReliefStyle;
 433
 434 /**
 435  * GtkResizeMode:
 436  * @GTK_RESIZE_PARENT: Pass resize request to the parent
 437  * @GTK_RESIZE_QUEUE: Queue resizes on this widget
 438  * @GTK_RESIZE_IMMEDIATE: Resize immediately. Deprecated.
 439  */
 440 typedef enum
 441 {
 442   GTK_RESIZE_PARENT,
 443   GTK_RESIZE_QUEUE,
 444   GTK_RESIZE_IMMEDIATE
 445 } GtkResizeMode;
 446
 447 /* scrolling types */
 448 typedef enum
 449 {
 450   GTK_SCROLL_NONE,
 451   GTK_SCROLL_JUMP,
 452   GTK_SCROLL_STEP_BACKWARD,
 453   GTK_SCROLL_STEP_FORWARD,
 454   GTK_SCROLL_PAGE_BACKWARD,
 455   GTK_SCROLL_PAGE_FORWARD,
 456   GTK_SCROLL_STEP_UP,
 457   GTK_SCROLL_STEP_DOWN,
 458   GTK_SCROLL_PAGE_UP,
 459   GTK_SCROLL_PAGE_DOWN,
 460   GTK_SCROLL_STEP_LEFT,
 461   GTK_SCROLL_STEP_RIGHT,
 462   GTK_SCROLL_PAGE_LEFT,
 463   GTK_SCROLL_PAGE_RIGHT,
 464   GTK_SCROLL_START,
 465   GTK_SCROLL_END
 466 } GtkScrollType;
 467
 468 /**
 469  * GtkSelectionMode:
 470  * @GTK_SELECTION_NONE: No selection is possible.
 471  * @GTK_SELECTION_SINGLE: Zero or one element may be selected.
 472  * @GTK_SELECTION_BROWSE: Exactly one element is selected. In some circumstances,
 473  *  such as initially or during a search operation, it's possible for no element
 474  *  to be selected with %GTK_SELECTION_BROWSE. What is really enforced is that
 475  *  the user can't deselect a currently selected element except by selecting
 476  *  another element.
 477  * @GTK_SELECTION_MULTIPLE: Any number of elements may be selected.
 478  *  Clicks toggle the state of an item. Any number of elements may be selected.
 479  *  The Ctrl key may be used to enlarge the selection, and Shift key to select
 480  *  between the focus and the child pointed to. Some widgets may also allow
 481  *  Click-drag to select a range of elements.
 482  * @GTK_SELECTION_EXTENDED: Deprecated, behaves identical to %GTK_SELECTION_MULTIPLE.
 483  *
 484  * Used to control what selections users are allowed to make.
 485  */
 486 typedef enum
 487 {
 488   GTK_SELECTION_NONE,
 489   GTK_SELECTION_SINGLE,
 490   GTK_SELECTION_BROWSE,
 491   GTK_SELECTION_MULTIPLE
 492 } GtkSelectionMode;
 493
 494 /**
 495  * GtkShadowType:
 496  * @GTK_SHADOW_NONE: No outline.
 497  * @GTK_SHADOW_IN: The outline is bevelled inwards.
 498  * @GTK_SHADOW_OUT: The outline is bevelled outwards like a button.
 499  * @GTK_SHADOW_ETCHED_IN: The outline has a sunken 3d appearance.
 500  * @GTK_SHADOW_ETCHED_OUT: The outline has a raised 3d appearance.
 501  *
 502  * Used to change the appearance of an outline typically provided by a #GtkFrame.
 503  */
 504 typedef enum
 505 {
 506   GTK_SHADOW_NONE,
 507   GTK_SHADOW_IN,
 508   GTK_SHADOW_OUT,
 509   GTK_SHADOW_ETCHED_IN,
 510   GTK_SHADOW_ETCHED_OUT
 511 } GtkShadowType;
 512
 513 /* Widget states */
 514
 515 /**
 516  * GtkStateType:
 517  * @GTK_STATE_NORMAL: State during normal operation.
 518  * @GTK_STATE_ACTIVE: State of a currently active widget, such as a depressed button.
 519  * @GTK_STATE_PRELIGHT: State indicating that the mouse pointer is over
 520  *                      the widget and the widget will respond to mouse clicks.
 521  * @GTK_STATE_SELECTED: State of a selected item, such the selected row in a list.
 522  * @GTK_STATE_INSENSITIVE: State indicating that the widget is
 523  *                         unresponsive to user actions.
 524  * @GTK_STATE_INCONSISTENT: The widget is inconsistent, such as checkbuttons
 525  *                          or radiobuttons that aren't either set to %TRUE nor %FALSE,
 526  *                          or buttons requiring the user attention.
 527  * @GTK_STATE_FOCUSED: The widget has the keyboard focus.
 528  *
 529  * This type indicates the current state of a widget; the state determines how
 530  * the widget is drawn. The #GtkStateType enumeration is also used to
 531  * identify different colors in a #GtkStyle for drawing, so states can be
 532  * used for subparts of a widget as well as entire widgets.
 533  */
 534 typedef enum
 535 {
 536   GTK_STATE_NORMAL,
 537   GTK_STATE_ACTIVE,
 538   GTK_STATE_PRELIGHT,
 539   GTK_STATE_SELECTED,
 540   GTK_STATE_INSENSITIVE,
 541   GTK_STATE_INCONSISTENT,
 542   GTK_STATE_FOCUSED
 543 } GtkStateType;
 544
 545 /**
 546  * GtkToolbarStyle:
 547  * @GTK_TOOLBAR_ICONS: Buttons display only icons in the toolbar.
 548  * @GTK_TOOLBAR_TEXT: Buttons display only text labels in the toolbar.
 549  * @GTK_TOOLBAR_BOTH: Buttons display text and icons in the toolbar.
 550  * @GTK_TOOLBAR_BOTH_HORIZ: Buttons display icons and text alongside each
 551  *  other, rather than vertically stacked
 552  *
 553  * Used to customize the appearance of a #GtkToolbar. Note that
 554  * setting the toolbar style overrides the user's preferences
 555  * for the default toolbar style.  Note that if the button has only
 556  * a label set and GTK_TOOLBAR_ICONS is used, the label will be
 557  * visible, and vice versa.
 558  */
 559 typedef enum
 560 {
 561   GTK_TOOLBAR_ICONS,
 562   GTK_TOOLBAR_TEXT,
 563   GTK_TOOLBAR_BOTH,
 564   GTK_TOOLBAR_BOTH_HORIZ
 565 } GtkToolbarStyle;
 566
 567 /**
 568  * GtkWindowPosition:
 569  * @GTK_WIN_POS_NONE: No influence is made on placement.
 570  * @GTK_WIN_POS_CENTER: Windows should be placed in the center of the screen.
 571  * @GTK_WIN_POS_MOUSE: Windows should be placed at the current mouse position.
 572  * @GTK_WIN_POS_CENTER_ALWAYS: Keep window centered as it changes size, etc.
 573  * @GTK_WIN_POS_CENTER_ON_PARENT: Center the window on its transient
 574  *  parent (see gtk_window_set_transient_for()).
 575  *
 576  * Window placement can be influenced using this enumeration. Note that
 577  * using #GTK_WIN_POS_CENTER_ALWAYS is almost always a bad idea.
 578  * It won't necessarily work well with all window managers or on all windowing systems.
 579  */
 580 typedef enum
 581 {
 582   GTK_WIN_POS_NONE,
 583   GTK_WIN_POS_CENTER,
 584   GTK_WIN_POS_MOUSE,
 585   GTK_WIN_POS_CENTER_ALWAYS,
 586   GTK_WIN_POS_CENTER_ON_PARENT
 587 } GtkWindowPosition;
 588
 589 /**
 590  * GtkWindowType:
 591  * @GTK_WINDOW_TOPLEVEL: A regular window, such as a dialog.
 592  * @GTK_WINDOW_POPUP: A special window such as a tooltip.
 593  *
 594  * A #GtkWindow can be one of these types. Most things you'd consider a
 595  * "window" should have type #GTK_WINDOW_TOPLEVEL; windows with this type
 596  * are managed by the window manager and have a frame by default (call
 597  * gtk_window_set_decorated() to toggle the frame).  Windows with type
 598  * #GTK_WINDOW_POPUP are ignored by the window manager; window manager
 599  * keybindings won't work on them, the window manager won't decorate the
 600  * window with a frame, many GTK+ features that rely on the window
 601  * manager will not work (e.g. resize grips and
 602  * maximization/minimization). #GTK_WINDOW_POPUP is used to implement
 603  * widgets such as #GtkMenu or tooltips that you normally don't think of
 604  * as windows per se. Nearly all windows should be #GTK_WINDOW_TOPLEVEL.
 605  * In particular, do not use #GTK_WINDOW_POPUP just to turn off
 606  * the window borders; use gtk_window_set_decorated() for that.
 607  */
 608 typedef enum
 609 {
 610   GTK_WINDOW_TOPLEVEL,
 611   GTK_WINDOW_POPUP
 612 } GtkWindowType;
 613
 614 /* Text wrap */
 615 typedef enum
 616 {
 617   GTK_WRAP_NONE,
 618   GTK_WRAP_CHAR,
 619   GTK_WRAP_WORD,
 620   GTK_WRAP_WORD_CHAR
 621 } GtkWrapMode;
 622
 623 /**
 624  * GtkSortType:
 625  * @GTK_SORT_ASCENDING: Sorting is in ascending order.
 626  * @GTK_SORT_DESCENDING: Sorting is in descending order.
 627  *
 628  * Determines the direction of a sort.
 629  */
 630 typedef enum
 631 {
 632   GTK_SORT_ASCENDING,
 633   GTK_SORT_DESCENDING
 634 } GtkSortType;
 635
 636 /* Style for gtk input method preedit/status */
 637 typedef enum
 638 {
 639   GTK_IM_PREEDIT_NOTHING,
 640   GTK_IM_PREEDIT_CALLBACK,
 641   GTK_IM_PREEDIT_NONE
 642 } GtkIMPreeditStyle;
 643
 644 typedef enum
 645 {
 646   GTK_IM_STATUS_NOTHING,
 647   GTK_IM_STATUS_CALLBACK,
 648   GTK_IM_STATUS_NONE
 649 } GtkIMStatusStyle;
 650
 651 /**
 652  * GtkPackDirection:
 653  * @GTK_PACK_DIRECTION_LTR: Widgets are packed left-to-right
 654  * @GTK_PACK_DIRECTION_RTL: Widgets are packed right-to-left
 655  * @GTK_PACK_DIRECTION_TTB: Widgets are packed top-to-bottom
 656  * @GTK_PACK_DIRECTION_BTT: Widgets are packed bottom-to-top
 657  *
 658  * Determines how widgets should be packed insided menubars
 659  * and menuitems contained in menubars.
 660  */
 661 typedef enum
 662 {
 663   GTK_PACK_DIRECTION_LTR,
 664   GTK_PACK_DIRECTION_RTL,
 665   GTK_PACK_DIRECTION_TTB,
 666   GTK_PACK_DIRECTION_BTT
 667 } GtkPackDirection;
 668
 669 typedef enum
 670 {
 671   GTK_PRINT_PAGES_ALL,
 672   GTK_PRINT_PAGES_CURRENT,
 673   GTK_PRINT_PAGES_RANGES,
 674   GTK_PRINT_PAGES_SELECTION
 675 } GtkPrintPages;
 676
 677 typedef enum
 678 {
 679   GTK_PAGE_SET_ALL,
 680   GTK_PAGE_SET_EVEN,
 681   GTK_PAGE_SET_ODD
 682 } GtkPageSet;
 683
 684 typedef enum
 685 {
 686   GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM, /*< nick=lrtb >*/
 687   GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP, /*< nick=lrbt >*/
 688   GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM, /*< nick=rltb >*/
 689   GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP, /*< nick=rlbt >*/
 690   GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT, /*< nick=tblr >*/
 691   GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT, /*< nick=tbrl >*/
 692   GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT, /*< nick=btlr >*/
 693   GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT  /*< nick=btrl >*/
 694 } GtkNumberUpLayout;
 695
 696 typedef enum
 697 {
 698   GTK_PAGE_ORIENTATION_PORTRAIT,
 699   GTK_PAGE_ORIENTATION_LANDSCAPE,
 700   GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT,
 701   GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE
 702 } GtkPageOrientation;
 703
 704 typedef enum
 705 {
 706   GTK_PRINT_QUALITY_LOW,
 707   GTK_PRINT_QUALITY_NORMAL,
 708   GTK_PRINT_QUALITY_HIGH,
 709   GTK_PRINT_QUALITY_DRAFT
 710 } GtkPrintQuality;
 711
 712 typedef enum
 713 {
 714   GTK_PRINT_DUPLEX_SIMPLEX,
 715   GTK_PRINT_DUPLEX_HORIZONTAL,
 716   GTK_PRINT_DUPLEX_VERTICAL
 717 } GtkPrintDuplex;
 718
 719
 720 typedef enum
 721 {
 722   GTK_UNIT_PIXEL,
 723   GTK_UNIT_POINTS,
 724   GTK_UNIT_INCH,
 725   GTK_UNIT_MM
 726 } GtkUnit;
 727
 728 /**
 729  * GtkTreeViewGridLines:
 730  * @GTK_TREE_VIEW_GRID_LINES_NONE: No grid lines.
 731  * @GTK_TREE_VIEW_GRID_LINES_HORIZONTAL: Horizontal grid lines.
 732  * @GTK_TREE_VIEW_GRID_LINES_VERTICAL: Vertical grid lines.
 733  * @GTK_TREE_VIEW_GRID_LINES_BOTH: Horizontal and vertical grid lines.
 734  *
 735  * Used to indicate which grid lines to draw in a tree view.
 736  */
 737 typedef enum
 738 {
 739   GTK_TREE_VIEW_GRID_LINES_NONE,
 740   GTK_TREE_VIEW_GRID_LINES_HORIZONTAL,
 741   GTK_TREE_VIEW_GRID_LINES_VERTICAL,
 742   GTK_TREE_VIEW_GRID_LINES_BOTH
 743 } GtkTreeViewGridLines;
 744
 745 /**
 746  * GtkDragResult:
 747  * @GTK_DRAG_RESULT_SUCCESS: The drag operation was successful.
 748  * @GTK_DRAG_RESULT_NO_TARGET: No suitable drag target.
 749  * @GTK_DRAG_RESULT_USER_CANCELLED: The user cancelled the drag operation.
 750  * @GTK_DRAG_RESULT_TIMEOUT_EXPIRED: The drag operation timed out.
 751  * @GTK_DRAG_RESULT_GRAB_BROKEN: The pointer or keyboard grab used
 752  *  for the drag operation was broken.
 753  * @GTK_DRAG_RESULT_ERROR: The drag operation failed due to some
 754  *  unspecified error.
 755  *
 756  * Gives an indication why a drag operation failed.
 757  * The value can by obtained by connecting to the
 758  * #GtkWidget::drag-failed signal.
 759  */
 760 typedef enum
 761 {
 762   GTK_DRAG_RESULT_SUCCESS,
 763   GTK_DRAG_RESULT_NO_TARGET,
 764   GTK_DRAG_RESULT_USER_CANCELLED,
 765   GTK_DRAG_RESULT_TIMEOUT_EXPIRED,
 766   GTK_DRAG_RESULT_GRAB_BROKEN,
 767   GTK_DRAG_RESULT_ERROR
 768 } GtkDragResult;
 769
 770 /**
 771  * GtkSizeRequestMode:
 772  * @GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH: Prefer height-for-width geometry management
 773  * @GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT: Prefer width-for-height geometry management
 774  *
 775  * Specifies a preference for height-for-width or
 776  * width-for-height geometry management.
 777  */
 778 typedef enum
 779 {
 780   GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH = 0,
 781   GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT
 782 } GtkSizeRequestMode;
 783
 784 /**
 785  * GtkScrollablePolicy:
 786  * @GTK_SCROLL_MINIMUM: Scrollable adjustments are based on the minimum size
 787  * @GTK_SCROLL_NATURAL: Scrollable adjustments are based on the natural size
 788  *
 789  * Defines the policy to be used in a scrollable widget when updating
 790  * the scrolled window adjustments in a given orientation.
 791  */
 792 typedef enum
 793 {
 794   GTK_SCROLL_MINIMUM = 0,
 795   GTK_SCROLL_NATURAL
 796 } GtkScrollablePolicy;
 797
 798 /**
 799  * GtkStateFlags:
 800  * @GTK_STATE_FLAG_NORMAL: State during normal operation.
 801  * @GTK_STATE_FLAG_ACTIVE: Widget is active.
 802  * @GTK_STATE_FLAG_PRELIGHT: Widget has a mouse pointer over it.
 803  * @GTK_STATE_FLAG_SELECTED: Widget is selected.
 804  * @GTK_STATE_FLAG_INSENSITIVE: Widget is insensitive.
 805  * @GTK_STATE_FLAG_INCONSISTENT: Widget is inconsistent.
 806  * @GTK_STATE_FLAG_FOCUSED: Widget has the keyboard focus.
 807  *
 808  * Describes a widget state.
 809  */
 810 typedef enum
 811 {
 812   GTK_STATE_FLAG_NORMAL       = 0,
 813   GTK_STATE_FLAG_ACTIVE       = 1 << 0,
 814   GTK_STATE_FLAG_PRELIGHT     = 1 << 1,
 815   GTK_STATE_FLAG_SELECTED     = 1 << 2,
 816   GTK_STATE_FLAG_INSENSITIVE  = 1 << 3,
 817   GTK_STATE_FLAG_INCONSISTENT = 1 << 4,
 818   GTK_STATE_FLAG_FOCUSED      = 1 << 5
 819 } GtkStateFlags;
 820
 821 /**
 822  * GtkRegionFlags:
 823  * @GTK_REGION_EVEN: Region has an even number within a set.
 824  * @GTK_REGION_ODD: Region has an odd number within a set.
 825  * @GTK_REGION_FIRST: Region is the first one within a set.
 826  * @GTK_REGION_LAST: Region is the last one within a set.
 827  * @GTK_REGION_SORTED: Region is part of a sorted area.
 828  *
 829  * Describes a region within a widget.
 830  */
 831 typedef enum {
 832   GTK_REGION_EVEN    = 1 << 0,
 833   GTK_REGION_ODD     = 1 << 1,
 834   GTK_REGION_FIRST   = 1 << 2,
 835   GTK_REGION_LAST    = 1 << 3,
 836   GTK_REGION_SORTED  = 1 << 5
 837 } GtkRegionFlags;
 838
 839 /**
 840  * GtkJunctionSides:
 841  * @GTK_JUNCTION_NONE: No junctions.
 842  * @GTK_JUNCTION_CORNER_TOPLEFT: Element connects on the top-left corner.
 843  * @GTK_JUNCTION_CORNER_TOPRIGHT: Element connects on the top-right corner.
 844  * @GTK_JUNCTION_CORNER_BOTTOMLEFT: Element connects on the bottom-left corner.
 845  * @GTK_JUNCTION_CORNER_BOTTOMRIGHT: Element connects on the bottom-right corner.
 846  * @GTK_JUNCTION_TOP: Element connects on the top side.
 847  * @GTK_JUNCTION_BOTTOM: Element connects on the bottom side.
 848  * @GTK_JUNCTION_LEFT: Element connects on the left side.
 849  * @GTK_JUNCTION_RIGHT: Element connects on the right side.
 850  *
 851  * Describes how a rendered element connects to adjacent elements.
 852  */
 853 typedef enum {
 854   GTK_JUNCTION_NONE   = 0,
 855   GTK_JUNCTION_CORNER_TOPLEFT = 1 << 0,
 856   GTK_JUNCTION_CORNER_TOPRIGHT = 1 << 1,
 857   GTK_JUNCTION_CORNER_BOTTOMLEFT = 1 << 2,
 858   GTK_JUNCTION_CORNER_BOTTOMRIGHT = 1 << 3,
 859   GTK_JUNCTION_TOP    = (GTK_JUNCTION_CORNER_TOPLEFT | GTK_JUNCTION_CORNER_TOPRIGHT),
 860   GTK_JUNCTION_BOTTOM = (GTK_JUNCTION_CORNER_BOTTOMLEFT | GTK_JUNCTION_CORNER_BOTTOMRIGHT),
 861   GTK_JUNCTION_LEFT   = (GTK_JUNCTION_CORNER_TOPLEFT | GTK_JUNCTION_CORNER_BOTTOMLEFT),
 862   GTK_JUNCTION_RIGHT  = (GTK_JUNCTION_CORNER_TOPRIGHT | GTK_JUNCTION_CORNER_BOTTOMRIGHT)
 863 } GtkJunctionSides;
 864
 865 /**
 866  * GtkBorderStyle:
 867  * @GTK_BORDER_STYLE_NONE: No visible border
 868  * @GTK_BORDER_STYLE_SOLID: A solid border
 869  * @GTK_BORDER_STYLE_INSET: An inset border
 870  * @GTK_BORDER_STYLE_OUTSET: An outset border
 871  *
 872  * Describes how the border of a UI element should be rendered.
 873  */
 874 typedef enum {
 875   GTK_BORDER_STYLE_NONE,
 876   GTK_BORDER_STYLE_SOLID,
 877   GTK_BORDER_STYLE_INSET,
 878   GTK_BORDER_STYLE_OUTSET
 879 } GtkBorderStyle;
 880
 881 G_END_DECLS
 882
 883
 884 #endif /* __GTK_ENUMS_H__ */