X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkenums.h;h=dbc0e90ea09807e78590f1e5707a12f31f55edf2;hb=1f2cfb5619f0d7b1838e54c58738bae766d74c0b;hp=9fd47d7052995d41889e270b72e2c103b2fbbff0;hpb=d45fd566b171136a180fff3667a0c2d4f7f6d3aa;p=~andy%2Fgtk diff --git a/gtk/gtkenums.h b/gtk/gtkenums.h index 9fd47d705..dbc0e90ea 100644 --- a/gtk/gtkenums.h +++ b/gtk/gtkenums.h @@ -33,6 +33,14 @@ #include + +/** + * SECTION:gtkenum + * @Short_description: Public enumerated types used throughout GTK+ + * @Title: Standard Enumerations + */ + + G_BEGIN_DECLS /** @@ -55,6 +63,9 @@ G_BEGIN_DECLS * you have for example a 16x16 icon inside a 32x32 space, the icon * could be scaled and stretched, it could be centered, or it could be * positioned to one side of the space. + * + * Note that in horizontal context @GTK_ALIGN_START and @GTK_ALIGN_END + * are interpreted relative to text direction. */ typedef enum { @@ -64,7 +75,15 @@ typedef enum GTK_ALIGN_CENTER } GtkAlign; -/* Arrow placement */ + +/** + * GtkArrowPlacement: + * @GTK_ARROWS_BOTH: Place one arrow on each end of the menu. + * @GTK_ARROWS_START: Place both arrows at the top of the menu. + * @GTK_ARROWS_END: Place both arrows at the bottom of the menu. + * + * Used to specify the placement of scroll arrows in scrolling menus. + */ typedef enum { GTK_ARROWS_BOTH, @@ -72,7 +91,16 @@ typedef enum GTK_ARROWS_END } GtkArrowPlacement; -/* Arrow types */ +/** + * GtkArrowType + * @GTK_ARROW_UP: Represents an upward pointing arrow. + * @GTK_ARROW_DOWN: Represents a downward pointing arrow. + * @GTK_ARROW_LEFT: Represents a left pointing arrow. + * @GTK_ARROW_RIGHT: Represents a right pointing arrow. + * @GTK_ARROW_NONE: No arrow. Since 2.10. + * + * Used to indicate the direction in which a #GtkArrow should point. + */ typedef enum { GTK_ARROW_UP, @@ -82,7 +110,16 @@ typedef enum GTK_ARROW_NONE } GtkArrowType; -/* Attach options (for tables) */ +/** + * GtkAttachOptions: + * @GTK_EXPAND: the widget should expand to take up any extra space in its + * container that has been allocated. + * @GTK_SHRINK: the widget should shrink as and when possible. + * @GTK_FILL: the widget should fill the space allocated to it. + * + * Denotes the expansion properties that a widget will have when it (or its + * parent) is resized. + */ typedef enum { GTK_EXPAND = 1 << 0, @@ -90,7 +127,20 @@ typedef enum GTK_FILL = 1 << 2 } GtkAttachOptions; -/* Button box styles */ +/** + * GtkButtonBoxStyle: + * @GTK_BUTTONBOX_DEFAULT_STYLE: Default packing. + * @GTK_BUTTONBOX_SPREAD: Buttons are evenly spread across the box. + * @GTK_BUTTONBOX_EDGE: Buttons are placed at the edges of the box. + * @GTK_BUTTONBOX_START: Buttons are grouped towards the start of the box, + * (on the left for a HBox, or the top for a VBox). + * @GTK_BUTTONBOX_END: Buttons are grouped towards the end of the box, + * (on the right for a HBox, or the bottom for a VBox). + * @GTK_BUTTONBOX_CENTER: Buttons are centered in the box. Since 2.12. + * + * Used to dictate the style that a #GtkButtonBox uses to layout the buttons it + * contains. (See also: #GtkVButtonBox and #GtkHButtonBox). + */ typedef enum { GTK_BUTTONBOX_SPREAD = 1, @@ -100,6 +150,7 @@ typedef enum GTK_BUTTONBOX_CENTER } GtkButtonBoxStyle; + typedef enum { GTK_DELETE_CHARS, @@ -125,7 +176,15 @@ typedef enum GTK_DIR_RIGHT } GtkDirectionType; -/* Expander styles */ +/** + * GtkExpanderStyle: + * @GTK_EXPANDER_COLLAPSED: The style used for a collapsed subtree. + * @GTK_EXPANDER_SEMI_COLLAPSED: Intermediate style used during animation. + * @GTK_EXPANDER_SEMI_EXPANDED: Intermediate style used during animation. + * @GTK_EXPANDER_EXPANDED: The style used for an expanded subtree. + * + * Used to specify the style of the expanders drawn by a #GtkTreeView. + */ typedef enum { GTK_EXPANDER_COLLAPSED, @@ -171,7 +230,16 @@ typedef enum GTK_TEXT_DIR_RTL } GtkTextDirection; -/* justification for label and maybe other widgets (text?) */ +/** + * GtkJustification: + * @GTK_JUSTIFY_LEFT: The text is placed at the left edge of the label. + * @GTK_JUSTIFY_RIGHT: The text is placed at the right edge of the label. + * @GTK_JUSTIFY_CENTER: The text is placed in the center of the label. + * @GTK_JUSTIFY_FILL: The text is placed is distributed across the label. + * + * Used for justifying the text inside a #GtkLabel widget. (See also + * #GtkAlignment). + */ typedef enum { GTK_JUSTIFY_LEFT, @@ -180,7 +248,15 @@ typedef enum GTK_JUSTIFY_FILL } GtkJustification; -/* Menu keyboard movement types */ +/** + * GtkMenuDirectionType: + * @GTK_MENU_DIR_PARENT: To the parent menu shell + * @GTK_MENU_DIR_CHILD: To the submenu, if any, associated with the item + * @GTK_MENU_DIR_NEXT: To the next menu item + * @GTK_MENU_DIR_PREV: To the previous menu item + * + * An enumeration representing directional movements within a menu. + */ typedef enum { GTK_MENU_DIR_PARENT, @@ -208,13 +284,6 @@ typedef enum GTK_MESSAGE_OTHER } GtkMessageType; -typedef enum -{ - GTK_PIXELS, - GTK_INCHES, - GTK_CENTIMETERS -} GtkMetricType; - /** * GtkMovementStep: * @GTK_MOVEMENT_LOGICAL_POSITIONS: Move forward or back by graphemes @@ -252,14 +321,35 @@ typedef enum GTK_SCROLL_HORIZONTAL_ENDS } GtkScrollStep; -/* Orientation for toolbars, etc. */ +/** + * GtkOrientation: + * @GTK_ORIENTATION_HORIZONTAL: The widget is in horizontal orientation. + * @GTK_ORIENTATION_VERTICAL: The widget is in vertical orientation. + * + * Represents the orientation of widgets which can be switched between horizontal + * and vertical orientation on the fly, like #GtkToolbar. + */ typedef enum { GTK_ORIENTATION_HORIZONTAL, GTK_ORIENTATION_VERTICAL } GtkOrientation; -/* Placement type for scrolled window */ +/** + * GtkCornerType: + * @GTK_CORNER_TOP_LEFT: Place the scrollbars on the right and bottom of the + * widget (default behaviour). + * @GTK_CORNER_BOTTOM_LEFT: Place the scrollbars on the top and right of the + * widget. + * @GTK_CORNER_TOP_RIGHT: Place the scrollbars on the left and bottom of the + * widget. + * @GTK_CORNER_BOTTOM_RIGHT: Place the scrollbars on the top and left of the + * widget. + * + * Specifies which corner a child widget should be placed in when packed into + * a #GtkScrolledWindow. This is effectively the opposite of where the scroll + * bars are placed. + */ typedef enum { GTK_CORNER_TOP_LEFT, @@ -268,7 +358,14 @@ typedef enum GTK_CORNER_BOTTOM_RIGHT } GtkCornerType; -/* Packing types (for boxes) */ +/** + * GtkPackType: + * @GTK_PACK_START: The child is packed into the start of the box + * @GTK_PACK_END: The child is packed into the end of the box + * + * Represents the packing location #GtkBox children. (See: #GtkVBox, + * #GtkHBox, and #GtkButtonBox). + */ typedef enum { GTK_PACK_START, @@ -295,7 +392,15 @@ typedef enum GTK_PATH_CLASS } GtkPathType; -/* Scrollbar policy types (for scrolled windows) */ +/** + * GtkPolicyType: + * @GTK_POLICY_ALWAYS: The scrollbar is always visible. + * @GTK_POLICY_AUTOMATIC: The scrollbar will appear and disappear as necessary. For example, + * when all of a #GtkCList can not be seen. + * @GTK_POLICY_NEVER: The scrollbar will never appear. + * + * Determines when a scroll bar will be visible. + */ typedef enum { GTK_POLICY_ALWAYS, @@ -303,6 +408,17 @@ typedef enum GTK_POLICY_NEVER } GtkPolicyType; +/** + * GtkPositionType: + * @GTK_POS_LEFT: The feature is at the left edge. + * @GTK_POS_RIGHT: The feature is at the right edge. + * @GTK_POS_TOP: The feature is at the top edge. + * @GTK_POS_BOTTOM: The feature is at the bottom edge. + * + * Describes which edge of a widget a certain feature is positioned at, e.g. the + * tabs of a #GtkNotebook, the handle of a #GtkHandleBox or the label of a + * #GtkScale. + */ typedef enum { GTK_POS_LEFT, @@ -311,7 +427,14 @@ typedef enum GTK_POS_BOTTOM } GtkPositionType; -/* Style for buttons */ +/** + * GtkReliefStyle: + * @GTK_RELIEF_NORMAL: Draw a normal relief. + * @GTK_RELIEF_HALF: A half relief. + * @GTK_RELIEF_NONE: No relief. + * + * Indicated the relief to be drawn around a #GtkButton. + */ typedef enum { GTK_RELIEF_NORMAL, @@ -319,12 +442,17 @@ typedef enum GTK_RELIEF_NONE } GtkReliefStyle; -/* Resize type */ +/** + * GtkResizeMode: + * @GTK_RESIZE_PARENT: Pass resize request to the parent + * @GTK_RESIZE_QUEUE: Queue resizes on this widget + * @GTK_RESIZE_IMMEDIATE: Resize immediately. Deprecated. + */ typedef enum { - GTK_RESIZE_PARENT, /* Pass resize request to the parent */ - GTK_RESIZE_QUEUE, /* Queue resizes on this widget */ - GTK_RESIZE_IMMEDIATE /* Perform the resizes now */ + GTK_RESIZE_PARENT, + GTK_RESIZE_QUEUE, + GTK_RESIZE_IMMEDIATE } GtkResizeMode; /* scrolling types */ @@ -348,16 +476,42 @@ typedef enum GTK_SCROLL_END } GtkScrollType; -/* list selection modes */ +/** + * GtkSelectionMode: + * @GTK_SELECTION_NONE: No selection is possible. + * @GTK_SELECTION_SINGLE: Zero or one element may be selected. + * @GTK_SELECTION_BROWSE: Exactly one element is selected. + * In some circumstances, such as initially or during a search + * operation, it's possible for no element to be selected with + * %GTK_SELECTION_BROWSE. What is really enforced is that the user + * can't deselect a currently selected element except by selecting + * another element. + * @GTK_SELECTION_MULTIPLE: Any number of elements may be selected. + * The Ctrl key may be used to enlarge the selection, and Shift + * key to select between the focus and the child pointed to. + * Some widgets may also allow Click-drag to select a range of elements. + * @GTK_SELECTION_EXTENDED: Deprecated, behaves identical to %GTK_SELECTION_MULTIPLE. + * + * Used to control what selections users are allowed to make. + */ typedef enum { - GTK_SELECTION_NONE, /* Nothing can be selected */ + GTK_SELECTION_NONE, GTK_SELECTION_SINGLE, GTK_SELECTION_BROWSE, GTK_SELECTION_MULTIPLE } GtkSelectionMode; -/* Shadow types */ +/** + * GtkShadowType: + * @GTK_SHADOW_NONE: No outline. + * @GTK_SHADOW_IN: The outline is bevelled inwards. + * @GTK_SHADOW_OUT: The outline is bevelled outwards like a button. + * @GTK_SHADOW_ETCHED_IN: The outline has a sunken 3d appearance. + * @GTK_SHADOW_ETCHED_OUT: The outline has a raised 3d appearance. + * + * Used to change the appearance of an outline typically provided by a #GtkFrame. + */ typedef enum { GTK_SHADOW_NONE, @@ -368,16 +522,51 @@ typedef enum } GtkShadowType; /* Widget states */ + +/** + * GtkStateType: + * @GTK_STATE_NORMAL: State during normal operation. + * @GTK_STATE_ACTIVE: State of a currently active widget, such as a depressed button. + * @GTK_STATE_PRELIGHT: State indicating that the mouse pointer is over + * the widget and the widget will respond to mouse clicks. + * @GTK_STATE_SELECTED: State of a selected item, such the selected row in a list. + * @GTK_STATE_INSENSITIVE: State indicating that the widget is + * unresponsive to user actions. + * @GTK_STATE_INCONSISTENT: The widget is inconsistent, such as checkbuttons + * or radiobuttons that aren't either set to %TRUE nor %FALSE, + * or buttons requiring the user attention. + * @GTK_STATE_FOCUSED: The widget has the keyboard focus. + * + * This type indicates the current state of a widget; the state determines how + * the widget is drawn. The #GtkStateType enumeration is also used to + * identify different colors in a #GtkStyle for drawing, so states can be + * used for subparts of a widget as well as entire widgets. + */ typedef enum { GTK_STATE_NORMAL, GTK_STATE_ACTIVE, GTK_STATE_PRELIGHT, GTK_STATE_SELECTED, - GTK_STATE_INSENSITIVE + GTK_STATE_INSENSITIVE, + GTK_STATE_INCONSISTENT, + GTK_STATE_FOCUSED } GtkStateType; -/* Style for toolbars */ +/** + * GtkToolbarStyle: + * @GTK_TOOLBAR_ICONS: Buttons display only icons in the toolbar. + * @GTK_TOOLBAR_TEXT: Buttons display only text labels in the toolbar. + * @GTK_TOOLBAR_BOTH: Buttons display text and icons in the toolbar. + * @GTK_TOOLBAR_BOTH_HORIZ: Buttons display icons and text alongside each + * other, rather than vertically stacked + * + * Used to customize the appearance of a #GtkToolbar. Note that + * setting the toolbar style overrides the user's preferences + * for the default toolbar style. Note that if the button has only + * a label set and GTK_TOOLBAR_ICONS is used, the label will be + * visible, and vice versa. + */ typedef enum { GTK_TOOLBAR_ICONS, @@ -386,15 +575,19 @@ typedef enum GTK_TOOLBAR_BOTH_HORIZ } GtkToolbarStyle; -/* Data update types (for ranges) */ -typedef enum -{ - GTK_UPDATE_CONTINUOUS, - GTK_UPDATE_DISCONTINUOUS, - GTK_UPDATE_DELAYED -} GtkUpdateType; - -/* Window position types */ +/** + * GtkWindowPosition: + * @GTK_WIN_POS_NONE: No influence is made on placement. + * @GTK_WIN_POS_CENTER: Windows should be placed in the center of the screen. + * @GTK_WIN_POS_MOUSE: Windows should be placed at the current mouse position. + * @GTK_WIN_POS_CENTER_ALWAYS: Keep window centered as it changes size, etc. + * @GTK_WIN_POS_CENTER_ON_PARENT: Center the window on its transient + * parent (see gtk_window_set_transient_for()). + * + * Window placement can be influenced using this enumeration. Note that + * using #GTK_WIN_POS_CENTER_ALWAYS is almost always a bad idea. + * It won't necessarily work well with all window managers or on all windowing systems. + */ typedef enum { GTK_WIN_POS_NONE, @@ -404,14 +597,43 @@ typedef enum GTK_WIN_POS_CENTER_ON_PARENT } GtkWindowPosition; -/* Window types */ +/** + * GtkWindowType: + * @GTK_WINDOW_TOPLEVEL: A regular window, such as a dialog. + * @GTK_WINDOW_POPUP: A special window such as a tooltip. + * + * A #GtkWindow can be one of these types. Most things you'd consider a + * "window" should have type #GTK_WINDOW_TOPLEVEL; windows with this type + * are managed by the window manager and have a frame by default (call + * gtk_window_set_decorated() to toggle the frame). Windows with type + * #GTK_WINDOW_POPUP are ignored by the window manager; window manager + * keybindings won't work on them, the window manager won't decorate the + * window with a frame, many GTK+ features that rely on the window + * manager will not work (e.g. resize grips and + * maximization/minimization). #GTK_WINDOW_POPUP is used to implement + * widgets such as #GtkMenu or tooltips that you normally don't think of + * as windows per se. Nearly all windows should be #GTK_WINDOW_TOPLEVEL. + * In particular, do not use #GTK_WINDOW_POPUP just to turn off + * the window borders; use gtk_window_set_decorated() for that. + */ typedef enum { GTK_WINDOW_TOPLEVEL, GTK_WINDOW_POPUP } GtkWindowType; -/* Text wrap */ +/** + * GtkWrapMode: + * @GTK_WRAP_NONE: do not wrap lines; just make the text area wider + * @GTK_WRAP_CHAR: wrap text, breaking lines anywhere the cursor can + * appear (between characters, usually - if you want to be technical, + * between graphemes, see pango_get_log_attrs()) + * @GTK_WRAP_WORD: wrap text, breaking lines in between words + * @GTK_WRAP_WORD_CHAR: wrap text, breaking lines in between words, or if + * that is not enough, also between graphemes + * + * Describes a type of line wrapping. + */ typedef enum { GTK_WRAP_NONE, @@ -420,7 +642,13 @@ typedef enum GTK_WRAP_WORD_CHAR } GtkWrapMode; -/* How to sort */ +/** + * GtkSortType: + * @GTK_SORT_ASCENDING: Sorting is in ascending order. + * @GTK_SORT_DESCENDING: Sorting is in descending order. + * + * Determines the direction of a sort. + */ typedef enum { GTK_SORT_ASCENDING, @@ -442,6 +670,16 @@ typedef enum GTK_IM_STATUS_NONE } GtkIMStatusStyle; +/** + * GtkPackDirection: + * @GTK_PACK_DIRECTION_LTR: Widgets are packed left-to-right + * @GTK_PACK_DIRECTION_RTL: Widgets are packed right-to-left + * @GTK_PACK_DIRECTION_TTB: Widgets are packed top-to-bottom + * @GTK_PACK_DIRECTION_BTT: Widgets are packed bottom-to-top + * + * Determines how widgets should be packed insided menubars + * and menuitems contained in menubars. + */ typedef enum { GTK_PACK_DIRECTION_LTR, @@ -465,6 +703,20 @@ typedef enum GTK_PAGE_SET_ODD } GtkPageSet; +/** + * GtkNumberUpLayout: + * @GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM: + * @GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP: + * @GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM: + * @GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP: + * @GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT: + * @GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT: + * @GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT: + * @GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT: + * + * Used to determine the layout of pages on a sheet when printing + * multiple pages per sheet. + */ typedef enum { GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM, /*< nick=lrtb >*/ @@ -526,6 +778,21 @@ typedef enum GTK_TREE_VIEW_GRID_LINES_BOTH } GtkTreeViewGridLines; +/** + * GtkDragResult: + * @GTK_DRAG_RESULT_SUCCESS: The drag operation was successful. + * @GTK_DRAG_RESULT_NO_TARGET: No suitable drag target. + * @GTK_DRAG_RESULT_USER_CANCELLED: The user cancelled the drag operation. + * @GTK_DRAG_RESULT_TIMEOUT_EXPIRED: The drag operation timed out. + * @GTK_DRAG_RESULT_GRAB_BROKEN: The pointer or keyboard grab used + * for the drag operation was broken. + * @GTK_DRAG_RESULT_ERROR: The drag operation failed due to some + * unspecified error. + * + * Gives an indication why a drag operation failed. + * The value can by obtained by connecting to the + * #GtkWidget::drag-failed signal. + */ typedef enum { GTK_DRAG_RESULT_SUCCESS, @@ -540,6 +807,7 @@ typedef enum * GtkSizeRequestMode: * @GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH: Prefer height-for-width geometry management * @GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT: Prefer width-for-height geometry management + * @GTK_SIZE_REQUEST_CONSTANT_SIZE: Dont trade height-for-width or width-for-height * * Specifies a preference for height-for-width or * width-for-height geometry management. @@ -547,7 +815,8 @@ typedef enum typedef enum { GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH = 0, - GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT + GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT, + GTK_SIZE_REQUEST_CONSTANT_SIZE } GtkSizeRequestMode; /** @@ -564,6 +833,90 @@ typedef enum GTK_SCROLL_NATURAL } GtkScrollablePolicy; +/** + * GtkStateFlags: + * @GTK_STATE_FLAG_NORMAL: State during normal operation. + * @GTK_STATE_FLAG_ACTIVE: Widget is active. + * @GTK_STATE_FLAG_PRELIGHT: Widget has a mouse pointer over it. + * @GTK_STATE_FLAG_SELECTED: Widget is selected. + * @GTK_STATE_FLAG_INSENSITIVE: Widget is insensitive. + * @GTK_STATE_FLAG_INCONSISTENT: Widget is inconsistent. + * @GTK_STATE_FLAG_FOCUSED: Widget has the keyboard focus. + * + * Describes a widget state. + */ +typedef enum +{ + GTK_STATE_FLAG_NORMAL = 0, + GTK_STATE_FLAG_ACTIVE = 1 << 0, + GTK_STATE_FLAG_PRELIGHT = 1 << 1, + GTK_STATE_FLAG_SELECTED = 1 << 2, + GTK_STATE_FLAG_INSENSITIVE = 1 << 3, + GTK_STATE_FLAG_INCONSISTENT = 1 << 4, + GTK_STATE_FLAG_FOCUSED = 1 << 5 +} GtkStateFlags; + +/** + * GtkRegionFlags: + * @GTK_REGION_EVEN: Region has an even number within a set. + * @GTK_REGION_ODD: Region has an odd number within a set. + * @GTK_REGION_FIRST: Region is the first one within a set. + * @GTK_REGION_LAST: Region is the last one within a set. + * @GTK_REGION_ONLY: Region is the only one within a set. + * @GTK_REGION_SORTED: Region is part of a sorted area. + * + * Describes a region within a widget. + */ +typedef enum { + GTK_REGION_EVEN = 1 << 0, + GTK_REGION_ODD = 1 << 1, + GTK_REGION_FIRST = 1 << 2, + GTK_REGION_LAST = 1 << 3, + GTK_REGION_ONLY = 1 << 4, + GTK_REGION_SORTED = 1 << 5 +} GtkRegionFlags; + +/** + * GtkJunctionSides: + * @GTK_JUNCTION_NONE: No junctions. + * @GTK_JUNCTION_CORNER_TOPLEFT: Element connects on the top-left corner. + * @GTK_JUNCTION_CORNER_TOPRIGHT: Element connects on the top-right corner. + * @GTK_JUNCTION_CORNER_BOTTOMLEFT: Element connects on the bottom-left corner. + * @GTK_JUNCTION_CORNER_BOTTOMRIGHT: Element connects on the bottom-right corner. + * @GTK_JUNCTION_TOP: Element connects on the top side. + * @GTK_JUNCTION_BOTTOM: Element connects on the bottom side. + * @GTK_JUNCTION_LEFT: Element connects on the left side. + * @GTK_JUNCTION_RIGHT: Element connects on the right side. + * + * Describes how a rendered element connects to adjacent elements. + */ +typedef enum { + GTK_JUNCTION_NONE = 0, + GTK_JUNCTION_CORNER_TOPLEFT = 1 << 0, + GTK_JUNCTION_CORNER_TOPRIGHT = 1 << 1, + GTK_JUNCTION_CORNER_BOTTOMLEFT = 1 << 2, + GTK_JUNCTION_CORNER_BOTTOMRIGHT = 1 << 3, + GTK_JUNCTION_TOP = (GTK_JUNCTION_CORNER_TOPLEFT | GTK_JUNCTION_CORNER_TOPRIGHT), + GTK_JUNCTION_BOTTOM = (GTK_JUNCTION_CORNER_BOTTOMLEFT | GTK_JUNCTION_CORNER_BOTTOMRIGHT), + GTK_JUNCTION_LEFT = (GTK_JUNCTION_CORNER_TOPLEFT | GTK_JUNCTION_CORNER_BOTTOMLEFT), + GTK_JUNCTION_RIGHT = (GTK_JUNCTION_CORNER_TOPRIGHT | GTK_JUNCTION_CORNER_BOTTOMRIGHT) +} GtkJunctionSides; + +/** + * GtkBorderStyle: + * @GTK_BORDER_STYLE_NONE: No visible border + * @GTK_BORDER_STYLE_SOLID: A solid border + * @GTK_BORDER_STYLE_INSET: An inset border + * @GTK_BORDER_STYLE_OUTSET: An outset border + * + * Describes how the border of a UI element should be rendered. + */ +typedef enum { + GTK_BORDER_STYLE_NONE, + GTK_BORDER_STYLE_SOLID, + GTK_BORDER_STYLE_INSET, + GTK_BORDER_STYLE_OUTSET +} GtkBorderStyle; G_END_DECLS