| 15. Graphic User Interface |
| Module GTK |
inherit GTKSupport : GTKSupport
constant GTK.FALSE
constant GTK.GDK_ACTION_ASK
constant GTK.GDK_ACTION_COPY
constant GTK.GDK_ACTION_DEFAULT
constant GTK.GDK_ACTION_LINK
constant GTK.GDK_ACTION_MOVE
constant GTK.GDK_ACTION_PRIVATE
constant GTK.GDK_ALL_EVENTS_MASK
constant GTK.GDK_AND
constant GTK.GDK_AND_INVERT
constant GTK.GDK_AND_REVERSE
constant GTK.GDK_ARROW
constant GTK.GDK_BASED_ARROW_DOWN
constant GTK.GDK_BASED_ARROW_UP
constant GTK.GDK_BOAT
constant GTK.GDK_BOGOSITY
constant GTK.GDK_BOTTOM_LEFT_CORNER
constant GTK.GDK_BOTTOM_RIGHT_CORNER
constant GTK.GDK_BOTTOM_SIDE
constant GTK.GDK_BOTTOM_TEE
constant GTK.GDK_BOX_SPIRAL
constant GTK.GDK_BUTTON1_MASK
constant GTK.GDK_BUTTON1_MOTION_MASK
constant GTK.GDK_BUTTON2_MASK
constant GTK.GDK_BUTTON2_MOTION_MASK
constant GTK.GDK_BUTTON3_MASK
constant GTK.GDK_BUTTON3_MOTION_MASK
constant GTK.GDK_BUTTON_MOTION_MASK
constant GTK.GDK_BUTTON_PRESS_MASK
constant GTK.GDK_BUTTON_RELEASE_MASK
constant GTK.GDK_CAP_BUTT
constant GTK.GDK_CAP_NOT_LAST
constant GTK.GDK_CAP_PROJECTING
constant GTK.GDK_CAP_ROUND
constant GTK.GDK_CENTER_PTR
constant GTK.GDK_CIRCLE
constant GTK.GDK_CLEAR
constant GTK.GDK_CLOCK
constant GTK.GDK_COFFEE_MUG
constant GTK.GDK_CONTROL_MASK
constant GTK.GDK_COPY
constant GTK.GDK_COPY_INVERT
constant GTK.GDK_CROSS
constant GTK.GDK_CROSSHAIR
constant GTK.GDK_CROSS_REVERSE
constant GTK.GDK_DECOR_ALL
constant GTK.GDK_DECOR_BORDER
constant GTK.GDK_DECOR_MAXIMIZE
constant GTK.GDK_DECOR_MENU
constant GTK.GDK_DECOR_MINIMIZE
constant GTK.GDK_DECOR_RESIZEH
constant GTK.GDK_DECOR_TITLE
constant GTK.GDK_DIAMOND_CROSS
constant GTK.GDK_DOT
constant GTK.GDK_DOTBOX
constant GTK.GDK_DOUBLE_ARROW
constant GTK.GDK_DRAFT_LARGE
constant GTK.GDK_DRAFT_SMALL
constant GTK.GDK_DRAG_PROTO_MOTIF
constant GTK.GDK_DRAG_PROTO_ROOTWIN
constant GTK.GDK_DRAG_PROTO_XDND
constant GTK.GDK_DRAPED_BOX
constant GTK.GDK_ENTER_NOTIFY_MASK
constant GTK.GDK_EQUIV
constant GTK.GDK_EVEN_ODD_RULE
constant GTK.GDK_EXCHANGE
constant GTK.GDK_EXPOSURE_MASK
constant GTK.GDK_EXTENSION_EVENTS_ALL
constant GTK.GDK_EXTENSION_EVENTS_CURSOR
constant GTK.GDK_EXTENSION_EVENTS_NONE
constant GTK.GDK_FLEUR
constant GTK.GDK_FOCUS_CHANGE_MASK
constant GTK.GDK_FUNC_ALL
constant GTK.GDK_FUNC_CLOSE
constant GTK.GDK_FUNC_MAXIMIZE
constant GTK.GDK_FUNC_MINIMIZE
constant GTK.GDK_FUNC_MOVE
constant GTK.GDK_FUNC_RESIZE
constant GTK.GDK_GL_ACCUM_ALPHA_SIZE
constant GTK.GDK_GL_ACCUM_BLUE_SIZE
constant GTK.GDK_GL_ACCUM_GREEN_SIZE
constant GTK.GDK_GL_ACCUM_RED_SIZE
constant GTK.GDK_GL_ALPHA_SIZE
constant GTK.GDK_GL_AUX_BUFFERS
constant GTK.GDK_GL_BLUE_SIZE
constant GTK.GDK_GL_BUFFER_SIZE
constant GTK.GDK_GL_DEPTH_SIZE
constant GTK.GDK_GL_DOUBLEBUFFER
constant GTK.GDK_GL_GREEN_SIZE
constant GTK.GDK_GL_LEVEL
constant GTK.GDK_GL_NONE
constant GTK.GDK_GL_RED_SIZE
constant GTK.GDK_GL_RGBA
constant GTK.GDK_GL_STENCIL_SIZE
constant GTK.GDK_GL_STEREO
constant GTK.GDK_GL_TRANSPARENT_ALPHA_VALUE_EXT
constant GTK.GDK_GL_TRANSPARENT_BLUE_VALUE_EXT
constant GTK.GDK_GL_TRANSPARENT_GREEN_VALUE_EXT
constant GTK.GDK_GL_TRANSPARENT_INDEX_VALUE_EXT
constant GTK.GDK_GL_TRANSPARENT_RED_VALUE_EXT
constant GTK.GDK_GL_TRANSPARENT_TYPE_EXT
constant GTK.GDK_GL_USE_GL
constant GTK.GDK_GL_X_VISUAL_TYPE_EXT
constant GTK.GDK_GOBBLER
constant GTK.GDK_GUMBY
constant GTK.GDK_HAND1
constant GTK.GDK_HAND2
constant GTK.GDK_HEART
constant GTK.GDK_ICON
constant GTK.GDK_IM_PREEDIT_AREA
constant GTK.GDK_IM_PREEDIT_CALLBACKS
constant GTK.GDK_IM_PREEDIT_MASK
constant GTK.GDK_IM_PREEDIT_NONE
constant GTK.GDK_IM_PREEDIT_NOTHING
constant GTK.GDK_IM_PREEDIT_POSITION
constant GTK.GDK_IM_STATUS_AREA
constant GTK.GDK_IM_STATUS_CALLBACKS
constant GTK.GDK_IM_STATUS_MASK
constant GTK.GDK_IM_STATUS_NONE
constant GTK.GDK_IM_STATUS_NOTHING
constant GTK.GDK_INVERT
constant GTK.GDK_IRON_CROSS
constant GTK.GDK_JOIN_BEVEL
constant GTK.GDK_JOIN_MITER
constant GTK.GDK_JOIN_ROUND
constant GTK.GDK_KEY_PRESS_MASK
constant GTK.GDK_KEY_RELEASE_MASK
constant GTK.GDK_LEAVE_NOTIFY_MASK
constant GTK.GDK_LEFTBUTTON
constant GTK.GDK_LEFT_PTR
constant GTK.GDK_LEFT_SIDE
constant GTK.GDK_LEFT_TEE
constant GTK.GDK_LINE_DOUBLE_DASH
constant GTK.GDK_LINE_ON_OFF_DASH
constant GTK.GDK_LINE_SOLID
constant GTK.GDK_LL_ANGLE
constant GTK.GDK_LOCK_MASK
constant GTK.GDK_LR_ANGLE
constant GTK.GDK_MAN
constant GTK.GDK_MIDDLEBUTTON
constant GTK.GDK_MOD1_MASK
constant GTK.GDK_MOD2_MASK
constant GTK.GDK_MOD3_MASK
constant GTK.GDK_MOD4_MASK
constant GTK.GDK_MOD5_MASK
constant GTK.GDK_MOUSE
constant GTK.GDK_NAND
constant GTK.GDK_NOOP
constant GTK.GDK_OPAQUE_STIPPLED
constant GTK.GDK_OR
constant GTK.GDK_OR_INVERT
constant GTK.GDK_OR_REVERSE
constant GTK.GDK_OVERLAP_RECTANGLE_IN
constant GTK.GDK_OVERLAP_RECTANGLE_OUT
constant GTK.GDK_OVERLAP_RECTANGLE_PART
constant GTK.GDK_PENCIL
constant GTK.GDK_PIRATE
constant GTK.GDK_PLUS
constant GTK.GDK_POINTER_MOTION_HINT_MASK
constant GTK.GDK_POINTER_MOTION_MASK
constant GTK.GDK_PROPERTY_CHANGE_MASK
constant GTK.GDK_PROP_MODE_APPEND
constant GTK.GDK_PROP_MODE_PREPEND
constant GTK.GDK_PROP_MODE_REPLACE
constant GTK.GDK_PROXIMITY_IN_MASK
constant GTK.GDK_PROXIMITY_OUT_MASK
constant GTK.GDK_QUESTION_ARROW
constant GTK.GDK_RIGHTBUTTON
constant GTK.GDK_RIGHT_PTR
constant GTK.GDK_RIGHT_SIDE
constant GTK.GDK_RIGHT_TEE
constant GTK.GDK_RTL_LOGO
constant GTK.GDK_SAILBOAT
constant GTK.GDK_SB_DOWN_ARROW
constant GTK.GDK_SB_H_DOUBLE_ARROW
constant GTK.GDK_SB_LEFT_ARROW
constant GTK.GDK_SB_RIGHT_ARROW
constant GTK.GDK_SB_UP_ARROW
constant GTK.GDK_SB_V_DOUBLE_ARROW
constant GTK.GDK_SELECTION_TYPE_ATOM
constant GTK.GDK_SELECTION_TYPE_BITMAP
constant GTK.GDK_SELECTION_TYPE_COLORMAP
constant GTK.GDK_SELECTION_TYPE_DRAWABLE
constant GTK.GDK_SELECTION_TYPE_INTEGER
constant GTK.GDK_SELECTION_TYPE_PIXMAP
constant GTK.GDK_SELECTION_TYPE_STRING
constant GTK.GDK_SELECTION_TYPE_WINDOW
constant GTK.GDK_SET
constant GTK.GDK_SHIFT_MASK
constant GTK.GDK_SHUTTLE
constant GTK.GDK_SIZING
constant GTK.GDK_SOLID
constant GTK.GDK_SPIDER
constant GTK.GDK_SPRAYCAN
constant GTK.GDK_STAR
constant GTK.GDK_STIPPLED
constant GTK.GDK_STRUCTURE_MASK
constant GTK.GDK_TARGET
constant GTK.GDK_TARGET_BITMAP
constant GTK.GDK_TARGET_COLORMAP
constant GTK.GDK_TARGET_DRAWABLE
constant GTK.GDK_TARGET_PIXMAP
constant GTK.GDK_TARGET_STRING
constant GTK.GDK_TCROSS
constant GTK.GDK_TILED
constant GTK.GDK_TOP_LEFT_ARROW
constant GTK.GDK_TOP_LEFT_CORNER
constant GTK.GDK_TOP_RIGHT_CORNER
constant GTK.GDK_TOP_SIDE
constant GTK.GDK_TOP_TEE
constant GTK.GDK_TREK
constant GTK.GDK_UL_ANGLE
constant GTK.GDK_UMBRELLA
constant GTK.GDK_UR_ANGLE
constant GTK.GDK_VISIBILITY_NOTIFY_MASK
constant GTK.GDK_WATCH
constant GTK.GDK_WINDING_RULE
constant GTK.GDK_WINDOW_CHILD
constant GTK.GDK_WINDOW_DIALOG
constant GTK.GDK_WINDOW_FOREIGN
constant GTK.GDK_WINDOW_ROOT
constant GTK.GDK_WINDOW_TEMP
constant GTK.GDK_WINDOW_TOPLEVEL
constant GTK.GDK_XOR
constant GTK.GDK_XTERM
constant GTK.GNOME_DOCK_BOTTOM
constant GTK.GNOME_DOCK_ITEM_BEH_EXCLUSIVE
constant GTK.GNOME_DOCK_ITEM_BEH_LOCKED
constant GTK.GNOME_DOCK_ITEM_BEH_NEVER_FLOATING
constant GTK.GNOME_DOCK_ITEM_BEH_NEVER_HORIZONTAL
constant GTK.GNOME_DOCK_ITEM_BEH_NEVER_VERTICAL
constant GTK.GNOME_DOCK_ITEM_BEH_NORMAL
constant GTK.GNOME_DOCK_LEFT
constant GTK.GNOME_DOCK_RIGHT
constant GTK.GNOME_DOCK_TOP
constant GTK.GNOME_FONT_PICKER_MODE_FONT_INFO
constant GTK.GNOME_FONT_PICKER_MODE_PIXMAP
constant GTK.GNOME_FONT_PICKER_MODE_UNKNOWN
constant GTK.GNOME_FONT_PICKER_MODE_USER_WIDGET
constant GTK.GNOME_ICON_LIST_ICONS
constant GTK.GNOME_ICON_LIST_IS_EDITABLE
constant GTK.GNOME_ICON_LIST_STATIC_TEXT
constant GTK.GNOME_ICON_LIST_TEXT_BELOW
constant GTK.GNOME_ICON_LIST_TEXT_RIGHT
constant GTK.GNOME_MESSAGE_BOX_ERROR
constant GTK.GNOME_MESSAGE_BOX_GENERIC
constant GTK.GNOME_MESSAGE_BOX_INFO
constant GTK.GNOME_MESSAGE_BOX_QUESTION
constant GTK.GNOME_MESSAGE_BOX_WARNING
constant GTK.GNOME_PREFERENCES_ALWAYS
constant GTK.GNOME_PREFERENCES_NEVER
constant GTK.GNOME_PREFERENCES_USER
constant GTK.GNOME_Panel_ORIENT_DOWN
constant GTK.GNOME_Panel_ORIENT_LEFT
constant GTK.GNOME_Panel_ORIENT_RIGHT
constant GTK.GNOME_Panel_ORIENT_UP
constant GTK.GNOME_STOCK_BUTTON_APPLY
constant GTK.GNOME_STOCK_BUTTON_CANCEL
constant GTK.GNOME_STOCK_BUTTON_CLOSE
constant GTK.GNOME_STOCK_BUTTON_DOWN
constant GTK.GNOME_STOCK_BUTTON_FONT
constant GTK.GNOME_STOCK_BUTTON_HELP
constant GTK.GNOME_STOCK_BUTTON_NEXT
constant GTK.GNOME_STOCK_BUTTON_NO
constant GTK.GNOME_STOCK_BUTTON_OK
constant GTK.GNOME_STOCK_BUTTON_PREV
constant GTK.GNOME_STOCK_BUTTON_UP
constant GTK.GNOME_STOCK_BUTTON_YES
constant GTK.GNOME_STOCK_MENU_ABOUT
constant GTK.GNOME_STOCK_MENU_ALIGN_CENTER
constant GTK.GNOME_STOCK_MENU_ALIGN_JUSTIFY
constant GTK.GNOME_STOCK_MENU_ALIGN_LEFT
constant GTK.GNOME_STOCK_MENU_ALIGN_RIGHT
constant GTK.GNOME_STOCK_MENU_ATTACH
constant GTK.GNOME_STOCK_MENU_BACK
constant GTK.GNOME_STOCK_MENU_BLANK
constant GTK.GNOME_STOCK_MENU_BOOK_BLUE
constant GTK.GNOME_STOCK_MENU_BOOK_GREEN
constant GTK.GNOME_STOCK_MENU_BOOK_OPEN
constant GTK.GNOME_STOCK_MENU_BOOK_RED
constant GTK.GNOME_STOCK_MENU_BOOK_YELLOW
constant GTK.GNOME_STOCK_MENU_BOTTOM
constant GTK.GNOME_STOCK_MENU_CDROM
constant GTK.GNOME_STOCK_MENU_CLOSE
constant GTK.GNOME_STOCK_MENU_CONVERT
constant GTK.GNOME_STOCK_MENU_COPY
constant GTK.GNOME_STOCK_MENU_CUT
constant GTK.GNOME_STOCK_MENU_DOWN
constant GTK.GNOME_STOCK_MENU_EXEC
constant GTK.GNOME_STOCK_MENU_EXIT
constant GTK.GNOME_STOCK_MENU_FIRST
constant GTK.GNOME_STOCK_MENU_FONT
constant GTK.GNOME_STOCK_MENU_FORWARD
constant GTK.GNOME_STOCK_MENU_HOME
constant GTK.GNOME_STOCK_MENU_INDEX
constant GTK.GNOME_STOCK_MENU_JUMP_TO
constant GTK.GNOME_STOCK_MENU_LAST
constant GTK.GNOME_STOCK_MENU_LINE_IN
constant GTK.GNOME_STOCK_MENU_MAIL
constant GTK.GNOME_STOCK_MENU_MAIL_FWD
constant GTK.GNOME_STOCK_MENU_MAIL_NEW
constant GTK.GNOME_STOCK_MENU_MAIL_RCV
constant GTK.GNOME_STOCK_MENU_MAIL_RPL
constant GTK.GNOME_STOCK_MENU_MAIL_SND
constant GTK.GNOME_STOCK_MENU_MIC
constant GTK.GNOME_STOCK_MENU_MIDI
constant GTK.GNOME_STOCK_MENU_NEW
constant GTK.GNOME_STOCK_MENU_OPEN
constant GTK.GNOME_STOCK_MENU_PASTE
constant GTK.GNOME_STOCK_MENU_PREF
constant GTK.GNOME_STOCK_MENU_PRINT
constant GTK.GNOME_STOCK_MENU_PROP
constant GTK.GNOME_STOCK_MENU_QUIT
constant GTK.GNOME_STOCK_MENU_REDO
constant GTK.GNOME_STOCK_MENU_REFRESH
constant GTK.GNOME_STOCK_MENU_REVERT
constant GTK.GNOME_STOCK_MENU_SAVE
constant GTK.GNOME_STOCK_MENU_SAVE_AS
constant GTK.GNOME_STOCK_MENU_SCORES
constant GTK.GNOME_STOCK_MENU_SEARCH
constant GTK.GNOME_STOCK_MENU_SPELLCHECK
constant GTK.GNOME_STOCK_MENU_SRCHRPL
constant GTK.GNOME_STOCK_MENU_STOP
constant GTK.GNOME_STOCK_MENU_TEXT_BOLD
constant GTK.GNOME_STOCK_MENU_TEXT_ITALIC
constant GTK.GNOME_STOCK_MENU_TEXT_STRIKEOUT
constant GTK.GNOME_STOCK_MENU_TEXT_UNDERLINE
constant GTK.GNOME_STOCK_MENU_TIMER
constant GTK.GNOME_STOCK_MENU_TIMER_STOP
constant GTK.GNOME_STOCK_MENU_TOP
constant GTK.GNOME_STOCK_MENU_TRASH
constant GTK.GNOME_STOCK_MENU_TRASH_FULL
constant GTK.GNOME_STOCK_MENU_UNDELETE
constant GTK.GNOME_STOCK_MENU_UNDO
constant GTK.GNOME_STOCK_MENU_UP
constant GTK.GNOME_STOCK_MENU_VOLUME
constant GTK.GNOME_STOCK_PIXMAP_ABOUT
constant GTK.GNOME_STOCK_PIXMAP_ADD
constant GTK.GNOME_STOCK_PIXMAP_ALIGN_CENTER
constant GTK.GNOME_STOCK_PIXMAP_ALIGN_JUSTIFY
constant GTK.GNOME_STOCK_PIXMAP_ALIGN_LEFT
constant GTK.GNOME_STOCK_PIXMAP_ALIGN_RIGHT
constant GTK.GNOME_STOCK_PIXMAP_ATTACH
constant GTK.GNOME_STOCK_PIXMAP_BACK
constant GTK.GNOME_STOCK_PIXMAP_BOOK_BLUE
constant GTK.GNOME_STOCK_PIXMAP_BOOK_GREEN
constant GTK.GNOME_STOCK_PIXMAP_BOOK_OPEN
constant GTK.GNOME_STOCK_PIXMAP_BOOK_RED
constant GTK.GNOME_STOCK_PIXMAP_BOOK_YELLOW
constant GTK.GNOME_STOCK_PIXMAP_BOTTOM
constant GTK.GNOME_STOCK_PIXMAP_CDROM
constant GTK.GNOME_STOCK_PIXMAP_CLEAR
constant GTK.GNOME_STOCK_PIXMAP_CLOSE
constant GTK.GNOME_STOCK_PIXMAP_COLORSELECTOR
constant GTK.GNOME_STOCK_PIXMAP_CONVERT
constant GTK.GNOME_STOCK_PIXMAP_COPY
constant GTK.GNOME_STOCK_PIXMAP_CUT
constant GTK.GNOME_STOCK_PIXMAP_DISABLED
constant GTK.GNOME_STOCK_PIXMAP_DOWN
constant GTK.GNOME_STOCK_PIXMAP_EXEC
constant GTK.GNOME_STOCK_PIXMAP_EXIT
constant GTK.GNOME_STOCK_PIXMAP_FIRST
constant GTK.GNOME_STOCK_PIXMAP_FOCUSED
constant GTK.GNOME_STOCK_PIXMAP_FONT
constant GTK.GNOME_STOCK_PIXMAP_FORWARD
constant GTK.GNOME_STOCK_PIXMAP_HELP
constant GTK.GNOME_STOCK_PIXMAP_HOME
constant GTK.GNOME_STOCK_PIXMAP_INDEX
constant GTK.GNOME_STOCK_PIXMAP_JUMP_TO
constant GTK.GNOME_STOCK_PIXMAP_LAST
constant GTK.GNOME_STOCK_PIXMAP_LINE_IN
constant GTK.GNOME_STOCK_PIXMAP_MAIL
constant GTK.GNOME_STOCK_PIXMAP_MAIL_FWD
constant GTK.GNOME_STOCK_PIXMAP_MAIL_NEW
constant GTK.GNOME_STOCK_PIXMAP_MAIL_RCV
constant GTK.GNOME_STOCK_PIXMAP_MAIL_RPL
constant GTK.GNOME_STOCK_PIXMAP_MAIL_SND
constant GTK.GNOME_STOCK_PIXMAP_MIC
constant GTK.GNOME_STOCK_PIXMAP_MIDI
constant GTK.GNOME_STOCK_PIXMAP_MULTIPLE
constant GTK.GNOME_STOCK_PIXMAP_NEW
constant GTK.GNOME_STOCK_PIXMAP_NOT
constant GTK.GNOME_STOCK_PIXMAP_OPEN
constant GTK.GNOME_STOCK_PIXMAP_PASTE
constant GTK.GNOME_STOCK_PIXMAP_PREFERENCES
constant GTK.GNOME_STOCK_PIXMAP_PRINT
constant GTK.GNOME_STOCK_PIXMAP_PROPERTIES
constant GTK.GNOME_STOCK_PIXMAP_QUIT
constant GTK.GNOME_STOCK_PIXMAP_REDO
constant GTK.GNOME_STOCK_PIXMAP_REFRESH
constant GTK.GNOME_STOCK_PIXMAP_REGULAR
constant GTK.GNOME_STOCK_PIXMAP_REMOVE
constant GTK.GNOME_STOCK_PIXMAP_REVERT
constant GTK.GNOME_STOCK_PIXMAP_SAVE
constant GTK.GNOME_STOCK_PIXMAP_SAVE_AS
constant GTK.GNOME_STOCK_PIXMAP_SCORES
constant GTK.GNOME_STOCK_PIXMAP_SEARCH
constant GTK.GNOME_STOCK_PIXMAP_SPELLCHECK
constant GTK.GNOME_STOCK_PIXMAP_SRCHRPL
constant GTK.GNOME_STOCK_PIXMAP_STOP
constant GTK.GNOME_STOCK_PIXMAP_TABLE_BORDERS
constant GTK.GNOME_STOCK_PIXMAP_TABLE_FILL
constant GTK.GNOME_STOCK_PIXMAP_TEXT_BOLD
constant GTK.GNOME_STOCK_PIXMAP_TEXT_BULLETED_LIST
constant GTK.GNOME_STOCK_PIXMAP_TEXT_INDENT
constant GTK.GNOME_STOCK_PIXMAP_TEXT_ITALIC
constant GTK.GNOME_STOCK_PIXMAP_TEXT_NUMBERED_LIST
constant GTK.GNOME_STOCK_PIXMAP_TEXT_STRIKEOUT
constant GTK.GNOME_STOCK_PIXMAP_TEXT_UNDERLINE
constant GTK.GNOME_STOCK_PIXMAP_TEXT_UNINDENT
constant GTK.GNOME_STOCK_PIXMAP_TIMER
constant GTK.GNOME_STOCK_PIXMAP_TIMER_STOP
constant GTK.GNOME_STOCK_PIXMAP_TOP
constant GTK.GNOME_STOCK_PIXMAP_TRASH
constant GTK.GNOME_STOCK_PIXMAP_TRASH_FULL
constant GTK.GNOME_STOCK_PIXMAP_TYPE_DATA
constant GTK.GNOME_STOCK_PIXMAP_TYPE_FILE
constant GTK.GNOME_STOCK_PIXMAP_TYPE_GPIXMAP
constant GTK.GNOME_STOCK_PIXMAP_TYPE_IMLIB
constant GTK.GNOME_STOCK_PIXMAP_TYPE_IMLIB_SCALED
constant GTK.GNOME_STOCK_PIXMAP_TYPE_NONE
constant GTK.GNOME_STOCK_PIXMAP_TYPE_PATH
constant GTK.GNOME_STOCK_PIXMAP_TYPE_WIDGET
constant GTK.GNOME_STOCK_PIXMAP_UNDELETE
constant GTK.GNOME_STOCK_PIXMAP_UNDO
constant GTK.GNOME_STOCK_PIXMAP_UP
constant GTK.GNOME_STOCK_PIXMAP_VOLUME
constant GTK.ACCEL_LOCKED
constant GTK.ACCEL_SIGNAL_VISIBLE
constant GTK.ACCEL_VISIBLE
constant GTK.ANCHOR_CENTER
constant GTK.ANCHOR_E
constant GTK.ANCHOR_EAST
constant GTK.ANCHOR_N
constant GTK.ANCHOR_NE
constant GTK.ANCHOR_NORTH
constant GTK.ANCHOR_NORTH_EAST
constant GTK.ANCHOR_NORTH_WEST
constant GTK.ANCHOR_NW
constant GTK.ANCHOR_S
constant GTK.ANCHOR_SE
constant GTK.ANCHOR_SOUTH
constant GTK.ANCHOR_SOUTH_EAST
constant GTK.ANCHOR_SOUTH_WEST
constant GTK.ANCHOR_SW
constant GTK.ANCHOR_W
constant GTK.ANCHOR_WEST
constant GTK.APP_PAINTABLE
constant GTK.ARROW_DOWN
constant GTK.ARROW_LEFT
constant GTK.ARROW_RIGHT
constant GTK.ARROW_UP
constant GTK.BUTTONBOX_DEFAULT_STYLE
constant GTK.BUTTONBOX_EDGE
constant GTK.BUTTONBOX_END
constant GTK.BUTTONBOX_SPREAD
constant GTK.BUTTONBOX_START
constant GTK.BUTTON_DRAGS
constant GTK.BUTTON_EXPANDS
constant GTK.BUTTON_IGNORED
constant GTK.BUTTON_SELECTS
constant GTK.CALENDAR_NO_MONTH_CHANGE
constant GTK.CALENDAR_SHOW_DAY_NAMES
constant GTK.CALENDAR_SHOW_HEADING
constant GTK.CALENDAR_SHOW_WEEK_NUMBERS
constant GTK.CALENDAR_WEEK_START_MONDAY
constant GTK.CAN_DEFAULT
constant GTK.CAN_FOCUS
constant GTK.CELL_EMPTY
constant GTK.CELL_PIXMAP
constant GTK.CELL_PIXTEXT
constant GTK.CELL_TEXT
constant GTK.CELL_WIDGET
constant GTK.CENTIMETERS
constant GTK.CLIST_ADD_MODE
constant GTK.CLIST_AUTO_RESIZE_BLOCKED
constant GTK.CLIST_AUTO_SORT
constant GTK.CLIST_DRAW_DRAG_LINE
constant GTK.CLIST_DRAW_DRAG_RECT
constant GTK.CLIST_IN_DRAG
constant GTK.CLIST_REORDERABLE
constant GTK.CLIST_ROW_HEIGHT_SET
constant GTK.CLIST_SHOW_TITLES
constant GTK.CLIST_USE_DRAG_ICONS
constant GTK.CLOCK_DECREASING
constant GTK.CLOCK_INCREASING
constant GTK.CLOCK_REALTIME
constant GTK.COMPOSITE_CHILD
constant GTK.CORNER_BOTTOM_LEFT
constant GTK.CORNER_BOTTOM_RIGHT
constant GTK.CORNER_TOP_LEFT
constant GTK.CORNER_TOP_RIGHT
constant GTK.CTREE_EXPANDER_CIRCULAR
constant GTK.CTREE_EXPANDER_NONE
constant GTK.CTREE_EXPANDER_SQUARE
constant GTK.CTREE_EXPANDER_TRIANGLE
constant GTK.CTREE_EXPANSION_COLLAPSE
constant GTK.CTREE_EXPANSION_COLLAPSE_RECURSIVE
constant GTK.CTREE_EXPANSION_EXPAND
constant GTK.CTREE_EXPANSION_EXPAND_RECURSIVE
constant GTK.CTREE_EXPANSION_TOGGLE
constant GTK.CTREE_EXPANSION_TOGGLE_RECURSIVE
constant GTK.CTREE_LINES_DOTTED
constant GTK.CTREE_LINES_NONE
constant GTK.CTREE_LINES_SOLID
constant GTK.CTREE_LINES_TABBED
constant GTK.CTREE_POS_AFTER
constant GTK.CTREE_POS_AS_CHILD
constant GTK.CTREE_POS_BEFORE
constant GTK.CURVE_TYPE_FREE
constant GTK.CURVE_TYPE_LINEAR
constant GTK.CURVE_TYPE_SPLINE
constant GTK.DATABOX_BARS
constant GTK.DATABOX_LINES
constant GTK.DATABOX_NOT_DISPLAYED
constant GTK.DATABOX_POINTS
constant GTK.DEST_DEFAULT_ALL
constant GTK.DEST_DEFAULT_DROP
constant GTK.DEST_DEFAULT_HIGHLIGHT
constant GTK.DEST_DEFAULT_MOTION
constant GTK.DIRECTION_LEFT
constant GTK.DIRECTION_RIGHT
constant GTK.DIR_DOWN
constant GTK.DIR_LEFT
constant GTK.DIR_RIGHT
constant GTK.DIR_TAB_BACKWARD
constant GTK.DIR_TAB_FORWARD
constant GTK.DIR_UP
constant GTK.EXPAND
constant GTK.FILL
constant GTK.FILL_X
constant GTK.FILL_Y
constant GTK.HAS_DEFAULT
constant GTK.HAS_FOCUS
constant GTK.HAS_GRAB
constant GTK.INCHES
constant GTK.JUSTIFY_CENTER
constant GTK.JUSTIFY_FILL
constant GTK.JUSTIFY_LEFT
constant GTK.JUSTIFY_RIGHT
constant GTK.LEFT_RIGHT
constant GTK.MAPPED
constant GTK.NO_REPARENT
constant GTK.NO_WINDOW
constant GTK.ORIENTATION_HORIZONTAL
constant GTK.ORIENTATION_VERTICAL
constant GTK.PACK_END
constant GTK.PACK_EXPAND
constant GTK.PACK_START
constant GTK.PARENT_SENSITIVE
constant GTK.PIXELS
constant GTK.POLICY_ALWAYS
constant GTK.POLICY_AUTOMATIC
constant GTK.POLICY_NEVER
constant GTK.POS_BOTTOM
constant GTK.POS_LEFT
constant GTK.POS_RIGHT
constant GTK.POS_TOP
constant GTK.PREVIEW_COLOR
constant GTK.PREVIEW_GRAYSCALE
constant GTK.PROGRESS_BOTTOM_TO_TOP
constant GTK.PROGRESS_CONTINUOUS
constant GTK.PROGRESS_DISCRETE
constant GTK.PROGRESS_LEFT_TO_RIGHT
constant GTK.PROGRESS_RIGHT_TO_LEFT
constant GTK.PROGRESS_TOP_TO_BOTTOM
constant GTK.RC_STYLE
constant GTK.REALIZED
constant GTK.RELIEF_HALF
constant GTK.RELIEF_NONE
constant GTK.RELIEF_NORMAL
constant GTK.RESIZE_IMMEDIATE
constant GTK.RESIZE_PARENT
constant GTK.RESIZE_QUEUE
constant GTK.RUN_BOTH
constant GTK.RUN_FIRST
constant GTK.RUN_LAST
constant GTK.RUN_NO_RECURSE
constant GTK.SCROLL_JUMP
constant GTK.SCROLL_NONE
constant GTK.SCROLL_PAGE_BACKWARD
constant GTK.SCROLL_PAGE_FORWARD
constant GTK.SCROLL_STEP_BACKWARD
constant GTK.SCROLL_STEP_FORWARD
constant GTK.SELECTION_BROWSE
constant GTK.SELECTION_EXTENDED
constant GTK.SELECTION_MULTIPLE
constant GTK.SELECTION_SINGLE
constant GTK.SENSITIVE
constant GTK.SHADOW_ETCHED_IN
constant GTK.SHADOW_ETCHED_OUT
constant GTK.SHADOW_IN
constant GTK.SHADOW_NONE
constant GTK.SHADOW_OUT
constant GTK.SHRINK
constant GTK.SIDE_BOTTOM
constant GTK.SIDE_LEFT
constant GTK.SIDE_RIGHT
constant GTK.SIDE_TOP
constant GTK.SORT_ASCENDING
constant GTK.SORT_DESCENDING
constant GTK.SPIN_END
constant GTK.SPIN_HOME
constant GTK.SPIN_PAGE_BACKWARD
constant GTK.SPIN_PAGE_FORWARD
constant GTK.SPIN_STEP_BACKWARD
constant GTK.SPIN_STEP_FORWARD
constant GTK.SPIN_USER_DEFINED
constant GTK.STATE_ACTIVE
constant GTK.STATE_INSENSITIVE
constant GTK.STATE_NORMAL
constant GTK.STATE_PRELIGHT
constant GTK.STATE_SELECTED
constant GTK.TOOLBAR_BOTH
constant GTK.TOOLBAR_ICONS
constant GTK.TOOLBAR_TEXT
constant GTK.TOPLEVEL
constant GTK.TOP_BOTTOM
constant GTK.TREE_VIEW_ITEM
constant GTK.TREE_VIEW_LINE
constant GTK.TROUGH_END
constant GTK.TROUGH_JUMP
constant GTK.TROUGH_NONE
constant GTK.TROUGH_START
constant GTK.UPDATE_ALWAYS
constant GTK.UPDATE_CONTINUOUS
constant GTK.UPDATE_DELAYED
constant GTK.UPDATE_DISCONTINUOUS
constant GTK.UPDATE_IF_VALID
constant GTK.VISIBILITY_FULL
constant GTK.VISIBILITY_NONE
constant GTK.VISIBILITY_PARTIAL
constant GTK.VISIBLE
constant GTK.WINDOW_DIALOG
constant GTK.WINDOW_POPUP
constant GTK.WINDOW_TOPLEVEL
constant GTK.WIN_POS_CENTER
constant GTK.WIN_POS_MOUSE
constant GTK.WIN_POS_NONE
constant GTK.TRUE
void applet_widget_gtk_main()
Special corba main loop for gnome panel applets
void applet_widget_gtk_main_quit()
Exit from the applet_widget_gtk_main function on the next iteration.
int false()
Always returns false.
void flush()
Flush GDK. Not normally needed, can be useful while doing calculations.
array gnome_init(string app_id, string app_version, array argv, int|void corba_init_flags)
Initializes the application. This sets up all of the GNOME internals and prepares them (imlib, gdk/gtk, session-management, triggers, sound, user preferences). If corba init flags are specified, corba initialization is done as well as gnome initialization. corba_init_flags is 0 or more of GNORBA_INIT_SERVER_FUNC (1), GNORBA_INIT_DISABLE_COOKIES (2) and GNORBA_INIT_CORBA_PRIO_HIGH (4)
void grab_add(GTK.Widget widget)
void grab_remove(GTK.Widget widget)
array gtk_init(array|void argc, int|void no_pgtkrc)
Low level GTK init function (used by setup_gtk). This function is more or less equivalent to the C-GTK+ function gtk_init. setup_gtk does some extra things (such as parsing ~/.pgtkrc).
void low_flush()
Flush, but do not process events. Not normally needed.
void main()
Start GTK in blocking mode. Doing this disables asynchronous I/O in pike. You can return -1 from main in pike to run GTK (and the rest of pike) in asynchrounous mode.
int main_iteration_do(int block)
Run one iteration in the mainloop. If block is true, wait for an event before returning.
int main_level()
Return the current recursion depth.
void main_quit()
Exit from the gtk_main function on the next iteration.
void parse_rc(string rc)
Takes a string and reads it as a gtkrc file.
GDK.Window root_window()
Returns the root window of the current display
int set_new_signal_convention(int n)
array setup_gtk(array|void argv, int|void do_not_parse_rc)
Initialize GTK, and all that comes with it. Also parses $HOME/.pgtkrc and $HOME/.gtkrc if they exists. The single argument, if supplied, is the argument array passed to the program. This is used to set default window titles etc. The second argument, if supplied, indicates that pike specific *rc files should not be parsed.
The most common usage is GTK.setup_gtk(argv);
int true()
Always returns true.
| CLASS GTK.Ruler |
Ruler widgets are used to indicate the location of the mouse pointer in a given window. A window can have a vertical ruler spanning across the width and a horizontal ruler spanning down the height. A small triangular indicator on the ruler shows the exact location of the pointer relative to the ruler.
inherit GTK.Widget : Widget
GTK.Ruler draw_pos()
draw the position
GTK.Ruler draw_ticks()
draw the ticks
float get_lower()
The currently defined lower extent of the ruler.
float get_max_size()
The currently defined max_size of the ruler.
float get_position()
The currently defined initial position of the pointer indicator within the ruler.
float get_upper()
The currently defined upper extent of the ruler.
GTK.Ruler set_metric(int unit)
Either GTK.Pixels, GTK.Centimers or GTK.Inches. The default measure is GTK.Pixels.
GTK.Ruler set_range(float lower, float upper, float position, float max_size)
The lower and upper arguments define the extent of the ruler, and max_size is the largest possible number that will be displayed. Position defines the initial position of the pointer indicator within the ruler.
| CLASS GTK.Window |
The basic window. Nothing much to say about it. It can only contain one child widget. Show the main window last to avoid annoying flashes when the subwidget (and it's subwidgets) are added to it, this is done automatically by calling 'window->show_all' when you are done with your widget packing.
Signals: move_resize
set_focus
inherit GTK.Bin : Bin
int activate_default()
Activate the default widget
int activate_focus()
Activate the focus widget
GTK.Window add_accel_group(GTK.AccelGroup group)
This function adds an accelerator group to the window. The shortcuts in the table will work in the window, it's child, and all children of it's child that do not select keyboard input.
GTK.Window add_embedded_xid(int x_window_id)
Add an embedded X-window
GTK.Window GTK.Window(int window_type)
Argument is one of WINDOW_DIALOG , WINDOW_POPUP and WINDOW_TOPLEVEL
int get_allow_grow()
If true, the window can grow if nessesary
int get_allow_shrink()
If true, the window can be shrunk by the user
int get_auto_shrink()
If true, the window will shrink if possible
GTK.Widget get_default_widget()
The default widget
GTK.Widget get_focus_widget()
The focus widget
int get_modal()
If true, this is a modal dialog window
string get_title()
The title of the window
GTK.Window get_transient_parent()
The parent window for this window if this is a transient window, 0 otherwise.
int get_type()
The window type, one of WINDOW_DIALOG , WINDOW_POPUP and WINDOW_TOPLEVEL
string get_wmclass_class()
The window manager class of this application.
string get_wmclass_name()
The window manager name of this application.
GTK.Window lower()
Lower this window if the window manager allows that.
GTK.Window raise()
Raise this window if the window manager allows that.
GTK.Window remove_accel_group(GTK.AccelGroup table)
Remove a previously installed table.
GTK.Window remove_embedded_xid(int x_window_id)
Remove the embeded X window
GTK.Window set_default(GTK.Widget default_widget)
Set the default widget to the specified widget. The specified widget must have the GTK.CanDefault flag set.
GTK.Window set_default_size(int width, int height)
The following differs from set_usize, in that set_usize() overrides the requisition, and thus sets a minimum size, while this only sets the size requested from the WM.
GTK.Window set_focus(GTK.Widget child)
Set the focus widget to the specified child. Please note that this is normaly handled automatically.
GTK.Window set_icon(GDK.Pixmap p, GDK.Bitmap b, GDK.Window w)
Set the icon to the specified image (with mask) or the specified GDK.Window. It is up to the window manager to display the icon. Most window manager handles window and pixmap icons, but only a few can handle the mask argument. If you want a shaped icon, the only safe bet is a shaped window.
GTK.Window set_icon_name(string name)
Set the icon name to the specified string.
GTK.Window set_modal(int modalp)
/ Is this a modal dialog?
GTK.Window set_policy(int allow_shrink, int allow_grow, int auto_shrink)
If allow shrink is true, the user can resize the window to a smaller size. If allow_grow is true, the window can resize itself, and the user can resize the window, to a bigger size. It auto shrink is true, the window will resize itself to a smaller size when it's subwidget is resized.
GTK.Window set_position(int pos)
one of WINDOW_DIALOG , WINDOW_POPUP , WINDOW_TOPLEVEL , WIN_POS_CENTER , WIN_POS_MOUSE and WIN_POS_NONE
GTK.Window set_title(string title)
Set the window title. The default title is the value sent to setup_gtk, or if none is sent, Pike GTK.
GTK.Window set_transient_for(GTK.Window parent)
Mark this window as a transient window for the parent window. Most window managers renders transient windows differently (different borders, sometimes no resize widgets etc)
Useful for short lived dialogs.
GTK.Window set_wmclass(string name, string class)
Set the window manager application name and class.
| CLASS GTK.Hscrollbar |
A horizontal scrollbar.
General documentation: See W(Scrollbar)
GTK.Hscrollbar(GTK.Adjustment())->set_usize(300,15)
![]()
inherit GTK.Scrollbar : Scrollbar
GTK.Hscrollbar GTK.Hscrollbar(GTK.Adjustment adjustment)
Used to create a new vscale widget. The adjustment argument can either be an existing W(Adjustment), or 0, in which case one will be created for you. Specifying 0 might actually be useful in this case, if you wish to pass the newly automatically created adjustment to the constructor function of some other widget which will configure it for you, such as a text widget.
| CLASS GTK.Dialog |
A dialog is a window with a few default widgets added. The 'vbox' is the main content area of the widget. The 'action_area' is allocated for buttons (ok, cancel etc)
inherit GTK.Window : Window
GTK.Dialog GTK.Dialog()
Create a new dialog widget.
GTK.HbuttonBox get_action_area()
The action area, this is where the buttons (ok, cancel etc) go
GTK.Vbox get_vbox()
The vertical box that should contain the contents of the dialog
| CLASS GTK.Calendar |
A calendar widget.
GTK.Calendar();

GTK.Calendar()->select_day( 16 );

Signals: day_selected
day_selected_double_click
month_changed
next_month
next_year
prev_month
prev_year
inherit GTK.Widget : Widget
GTK.Calendar clear_marks()
Remove all day markers
GTK.Calendar GTK.Calendar()
Create a new calendar widget
GTK.Calendar display_options(int options)
Bitwise or of one or more of CALENDAR_NO_MONTH_CHANGE , CALENDAR_SHOW_DAY_NAMES , CALENDAR_SHOW_HEADING , CALENDAR_SHOW_WEEK_NUMBERS and CALENDAR_WEEK_START_MONDAY .
GTK.Calendar freeze()
Suspend all dynamic updating of the widget
mapping get_date()
returns a mapping: ([ "year":year, "month":month, "day":day ])
array get_day()
Return an array of 6x7 days, representing the cells in the currently viewed calendar month.
array get_day_month()
Return an array of 6x7 days, representing the cells in the currently viewed calendar month. The value is the day of month.
int get_focus_col()
The currently focused column
int get_focus_row()
The currently focused row
int get_highlight_col()
The currently highlighted column
int get_highlight_row()
The currently highlighted row
array get_marked_dates()
Returns an array (with 31 elements) with 1es and 0es.
int get_month()
The current month
int get_num_marked_dates()
The number of days that are marked
int get_selected_day()
The currently selected day
int get_year()
The current year
GTK.Calendar mark_day(int day_of_month)
Mark a day
GTK.Calendar select_day(int day_of_month)
Select a certain day of the currently selected month
int select_month(int month, int year)
Select the month to be viewed.
GTK.Calendar set_marked_date_color(int index, GDK.Color color)
Set the color to use to mark dates
GTK.Calendar thaw()
Resume dynamic updating of the widget
GTK.Calendar unmark_day(int day_of_month)
Unmark a day
| CLASS GTK.Notebook |
The NoteBook Widget is a collection of 'pages' that overlap each other, each page contains different information. This widget has become more common lately in GUI programming, and it is a good way to show blocks similar information that warrant separation in their display.
GTK.Notebook( )->set_tab_pos( GTK.POS_LEFT )->append_page( GTK.Label("Page 1\nContents"), GTK.Label("Page 1"))->append_page( GTK.Label(""), GTK.Label("Page 2"))->append_page(GTK.Label("Page 3 contents\nare here!"), GTK.Label("Page 3"))

GTK.Notebook( )->set_tab_pos( GTK.POS_TOP )->append_page( GTK.Label("Page 1\nContents"), GTK.Label("Page 1"))->append_page( GTK.Label(""), GTK.Label("Page 2"))->append_page(GTK.Label("Page 3 contents\nare here!"), GTK.Label("Page 3"))

GTK.Notebook( )->set_tab_pos( GTK.POS_RIGHT )->append_page( GTK.Label("Page 1\nContents"), GTK.Label("Page 1"))->append_page( GTK.Label(""), GTK.Label("Page 2"))->append_page(GTK.Label("Page 3 contents\nare here!"), GTK.Label("Page 3"))->next_page()->next_page()

Signals: switch_page Called when a different page is selected
inherit GTK.Container : Container
GTK.Notebook append_page(GTK.Widget contents, GTK.Widget label)
Add a new 'page' to the notebook. The first argument is the contents of the page, the second argument is the label.
GTK.Notebook append_page_menu(GTK.Widget contents, GTK.Widget label, GTK.Menu menu)
Add a new 'page' to the notebook. The first argument is the contents of the page, the second argument is the label, the third argument is a menu widget.
GTK.Notebook GTK.Notebook()
int get_current_page()
Returns the index of the currently selected page
GTK.Widget get_menu_label(GTK.Widget page)
GTK.Widget get_nth_page(int index)
Returns the page for the specified index
GTK.Widget get_tab_label(GTK.Widget page)
GTK.Notebook insert_page(GTK.Widget contents, GTK.Widget label, int pos)
Insert a page at the specified location, arguments as for append_page, but an aditional integer specifies the location.
GTK.Notebook insert_page_menu(GTK.Widget contents, GTK.Widget label, GTK.Menu menu, int pos)
Insert a page at the specified location, arguments as for append_page_menu, but an aditional integer specifies the location.
GTK.Notebook next_page()
Go to the next page
int page_num(GTK.Widget widget)
Returns the index for the specified page
GTK.Notebook popup_disable()
Disable the popup menu (set with insert_page_menu)
GTK.Notebook popup_enable()
Enable the popup menu (set with insert_page_menu)
GTK.Notebook prepend_page(GTK.Widget contents, GTK.Widget label)
Add a page at the end of the list of pages. The first argument is the contents of the page, the second argument is the label.
GTK.Notebook prepend_page_menu(GTK.Widget contents, GTK.Widget label, GTK.Menu menu)
Add a new 'page' at the end of the list of pages. The first argument is the contents of the page, the second argument is the label, the third argument is a menu widget.
GTK.Notebook prev_page()
Go to the previous page
mapping query_tab_label_packing(GTK.Widget page)
Returns ([ "expand":expandp, "fill":fillp, "pack_type":type ])
GTK.Notebook remove_page(int pos)
Remove a page.
GTK.Notebook reorder_child(GTK.Widget page, int new_index)
Move the specified page to the index new_index
GTK.Notebook set_homogeneous_tabs(int homogeneousp)
If true, all tabs will have the same size
GTK.Notebook set_menu_label(GTK.Widget page, GTK.Widget label)
GTK.Notebook set_menu_label_text(GTK.Widget page, string label)
GTK.Notebook set_page(int pos)
Go to the specified page
GTK.Notebook set_scrollable(int scrollablep)
If true, add scrollbars if nessesary.
GTK.Notebook set_show_border(int showborderp)
If true, show the borders around the contents and tabs.
GTK.Notebook set_show_tabs(int showtabsp)
If supplied with a true value, the tabs will be shown. Otherwise they will not be shown. The user will not be able to select the pages without them, but you can add 'next' and 'previous' buttons to create a wizard-line interface.
GTK.Notebook set_tab_border(int border_width)
In pixels.
GTK.Notebook set_tab_hborder(int border_width)
In pixels.
GTK.Notebook set_tab_label(GTK.Widget page, GTK.Widget label)
GTK.Notebook set_tab_label_packing(GTK.Widget child, int expand, int fill, int type)
GTK.Notebook set_tab_label_text(GTK.Widget page, string title)
GTK.Notebook set_tab_pos(int pos)
One of POS_BOTTOM , POS_LEFT , POS_RIGHT and POS_TOP
GTK.Notebook set_tab_vborder(int border_width)
In pixels.
| CLASS GTK.GammaCurve |
A gamma curve widget.. Rather complex.
Lets the user edit a gamma curve (a one-to-one mapping usually used to adjust the intensity of an image to the physical characteristics of the output device). You can set the minimum and maximum values for input and output. You can set the initial vector as well. You are guaranteed that every input value will have a (not necessarily unique) output value specified.
GTK.GammaCurve()->set_usize(210,130)

inherit GTK.Vbox : Vbox
GTK.GammaCurve GTK.GammaCurve()
Create a new gamma curve
GTK.Curve get_curve()
The actual curve
float get_gamma()
The current gamma value
| CLASS GTK.GLArea |
inherit GTK.DrawingArea : DrawingArea
GTK.GLArea GTK.GLArea(array gloptions)
GTK.GLArea make_current()
GTK.GLArea swap_buffers()
GTK.GLArea wait_gdk()
GTK.GLArea wait_gl()
| CLASS GTK.Hscale |
The GTK.HScale widget is used to allow the user to select a value using a horizontal slider. A GTK.Adjustment is used to set the initial value, the lower and upper bounds, and the step and page increments.
See W(Scale) for details
The position to show the current value, and the number of decimal places shown can be set using the parent W(Scale) class's functions.
GTK.Hscale(GTK.Adjustment())->set_usize(300,30)
![]()
inherit GTK.Scale : Scale
GTK.Hscale GTK.Hscale(GTK.Adjustment settings)
Used to create a new hscale widget. The adjustment argument can either be an existing W(Adjustment), or 0, in which case one will be created for you.
| CLASS GTK.Tooltips |
Tooltips are the messages that appear next to a widget when the mouse pointer is held over it for a short amount of time. They are especially helpful for adding more verbose descriptions of things such as buttons in a toolbar.
An individual tooltip belongs to a group of tooltips. A group is created with a call to GTK.Tooltips(). Every tooltip in the group can then be turned off with a call to disable() and enabled with enable().
The length of time the user must keep the mouse over a widget before the tip is shown, can be altered with set_delay(). This is set on a 'per group of tooltips' basis.
To assign a tip to a particular W(Widget), set_tip() is used.
The default appearance of all tooltips in a program is determined by the current gtk theme that the user has selected. To change the tooltip appearance manually, use set_colors(). Again, this is per group of tooltips.
inherit GTK.Data : Data
GTK.Tooltips GTK.Tooltips()
Creates an empty group of tooltips. This function initialises a GTK.Tooltips structure. Without at least one such structure, you can not add tips to your application.
GTK.Tooltips disable()
Disable this tooltip collection
GTK.Tooltips enable()
Enable this tooltip collection
GTK.Tooltips force_window()
Realize the tooltip window (as returned from get_gdkwindow())
GTK.Tooltips set_colors(GDK.Color foreground, GDK.Color background)
Changes the foreground and background colors.
GTK.Tooltips set_delay(int delay)
Set the delat (in seconds)
GTK.Tooltips set_tip(GTK.Widget in, string to)
Adds a tooltip containing the message tip_text to the specified W(Widget).
| CLASS GTK.Bin |
A container that can only contain one child.
inherit GTK.Container : Container
GTK.Widget get_child()
Returns the (one and only) child of this container.
| CLASS GTK.Vpaned |
The paned window widgets are useful when you want to divide an area into two parts, with the relative size of the two parts controlled by the user. A groove is drawn between the two portions with a handle that the user can drag to change the ratio. This widgets makes a vertical division
GTK.Vpaned()->add1(GTK.Label("Top Side Of Pane"))->add2(GTK.Label("Bottom"))->set_usize(100,100)

inherit GTK.Paned : Paned
GTK.Vpaned GTK.Vpaned()
| CLASS GTK.Hpaned |
The paned window widgets are useful when you want to divide an area into two parts, with the relative size of the two parts controlled by the user. A groove is drawn between the two portions with a handle that the user can drag to change the ratio. This widgets makes a horizontal division
See W(Paned) for details.
GTK.Hpaned()->add1(GTK.Label("Left\nSide\nOf\nPane"))->add2(GTK.Label("Right\nSide\nOf\nPane"))->set_usize(100,100)

inherit GTK.Paned : Paned
GTK.Hpaned GTK.Hpaned()
| CLASS GTK.Vruler |
Ruler widgets are used to indicate the location of the mouse pointer in a given window. A window can have a vertical ruler spanning across the width and a horizontal ruler spanning down the height. A small triangular indicator on the ruler shows the exact location of the pointer relative to the ruler.
GTK.Vruler()->set_metric(GTK.PIXELS)->set_range(0.0,100.0,50.0,100.0)->draw_ticks()->draw_pos()->set_usize(30,50)
![]()
GTK.Vruler()->set_metric(GTK.CENTIMETERS)->set_range(0.0,100.0,50.0,100.0)->draw_ticks()->draw_pos()->set_usize(30,50)
![]()
GTK.Vruler()->set_usize(30,50)
![]()
inherit GTK.Ruler : Ruler
GTK.Vruler GTK.Vruler()
Used to create a new vruler widget.
| CLASS GTK.Vscale |
The GTK.VScale widget is used to allow the user to select a value using a vertical slider. A GtkAdjustment is used to set the initial value, the lower and upper bounds, and the step and page increments.
The position to show the current value, and the number of decimal places shown can be set using the parent W(Scale) class's functions.
GTK.Vscale(GTK.Adjustment())->set_usize(30,100)
![]()
inherit GTK.Scale : Scale
GTK.Vscale GTK.Vscale(GTK.Adjustment settings)
Used to create a new vscale widget. The adjustment argument can either be an existing W(Adjustment), or 0, in which case one will be created for you. Specifying 0 might actually be useful in this case, if you wish to pass the newly automatically created adjustment to the constructor function of some other widget which will configure it for you, such as a text widget.
| CLASS GTK.Packer |
inherit GTK.Container : Container
GTK.Packer add(GTK.Widget widget, int side, int anchor, int options, int border_width, int pad_x, int pad_y, int i_pad_x, int i_pad_y)
side is one of SIDE_BOTTOM , SIDE_LEFT , SIDE_RIGHT and SIDE_TOP , anchor is one of ANCHOR_CENTER , ANCHOR_E , ANCHOR_EAST , ANCHOR_N , ANCHOR_NE , ANCHOR_NORTH , ANCHOR_NORTH_EAST , ANCHOR_NORTH_WEST , ANCHOR_NW , ANCHOR_S , ANCHOR_SE , ANCHOR_SOUTH , ANCHOR_SOUTH_EAST , ANCHOR_SOUTH_WEST , ANCHOR_SW , ANCHOR_W and ANCHOR_WEST , options is a bitwise or of GTK.PackExpand, GTK.FillX and GTK.FillY
GTK.Packer add_defaults(GTK.Widget widget, int side, int anchor, int options)
side is one of SIDE_BOTTOM , SIDE_LEFT , SIDE_RIGHT and SIDE_TOP , anchor is one of ANCHOR_CENTER , ANCHOR_E , ANCHOR_EAST , ANCHOR_N , ANCHOR_NE , ANCHOR_NORTH , ANCHOR_NORTH_EAST , ANCHOR_NORTH_WEST , ANCHOR_NW , ANCHOR_S , ANCHOR_SE , ANCHOR_SOUTH , ANCHOR_SOUTH_EAST , ANCHOR_SOUTH_WEST , ANCHOR_SW , ANCHOR_W and ANCHOR_WEST , options is a bitwise or of GTK.PackExpand, GTK.FillX and GTK.FillY
GTK.Packer GTK.Packer()
int get_default_border_width()
int get_default_i_pad_x()
int get_default_i_pad_y()
int get_default_pad_x()
int get_default_pad_y()
int get_spacing()
GTK.Packer reorder_child(GTK.Widget child, int pos)
GTK.Packer set_child_packing(GTK.Widget child, int side, int anchor, int options, int border_width, int pad_x, int pad_y, int i_pad_x, int i_pad_y)
side is one of SIDE_BOTTOM , SIDE_LEFT , SIDE_RIGHT and SIDE_TOP , anchor is one of ANCHOR_CENTER , ANCHOR_E , ANCHOR_EAST , ANCHOR_N , ANCHOR_NE , ANCHOR_NORTH , ANCHOR_NORTH_EAST , ANCHOR_NORTH_WEST , ANCHOR_NW , ANCHOR_S , ANCHOR_SE , ANCHOR_SOUTH , ANCHOR_SOUTH_EAST , ANCHOR_SOUTH_WEST , ANCHOR_SW , ANCHOR_W and ANCHOR_WEST , options is a bitwise or of GTK.PackExpand, GTK.FillX and GTK.FillY
GTK.Packer set_default_border_width(int border)
GTK.Packer set_default_ipad(int xpad, int ypad)
GTK.Packer set_default_pad(int xpad, int ypad)
GTK.Packer set_spacing(int new_spacing)
| CLASS GTK.Invisible |
An invisible container, useful, eh? :)
inherit GTK.Bin : Bin
GTK.Invisible GTK.Invisible()
Create a new invisible widget
| CLASS GTK.ScrolledWindow |
Scrolled windows are used to create a scrollable area with another widget inside it. You may insert any type of widget into a scrolled window, and it will be accessible regardless of the size by using the scrollbars.
GTK.ScrolledWindow(GTK.Adjustment(),GTK.Adjustment())->add(GTK.Label("A small label"))->set_usize(100,80)->set_policy(GTK.POLICY_AUTOMATIC,GTK.POLICY_AUTOMATIC)

GTK.ScrolledWindow(GTK.Adjustment(),GTK.Adjustment())->add(GTK.Label("A small label"))->set_usize(70,80)->set_policy(GTK.POLICY_AUTOMATIC,GTK.POLICY_AUTOMATIC)

GTK.ScrolledWindow(GTK.Adjustment(),GTK.Adjustment())->add(GTK.Label("A small label"))->set_usize(80,80)

GTK.ScrolledWindow(GTK.Adjustment(),GTK.Adjustment())->add(GTK.Label("A very huge label")->set_usize(700,700))->set_usize(80,80)

inherit GTK.Window : Window
GTK.ScrolledWindow add(GTK.Widget victim)
Add a widget to this container. This is equivalent to the C-GTK function gtk_scrolled_window_add_with_viewport or gtk_container_add, depeneding on whether or not the child supports the set_scroll_adjustments signal.
What this means in practice is that you do not have to care about this at all, it's all handled automatically.
GTK.ScrolledWindow GTK.ScrolledWindow(GTK.Adjustment hadjustment, GTK.Adjustment vadjustments)
The two adjustments are most commonly set to 0.
GTK.Adjustment get_hadjustment()
Return the horizontal adjustment used to scroll the window
GTK.Hscrollbar get_hscrollbar()
The horizontal scrollbar
int get_hscrollbar_policy()
One of POLICY_ALWAYS , POLICY_AUTOMATIC and POLICY_NEVER
int get_hscrollbar_visible()
1 if the horizontal scrollbar is currently visible
GTK.Adjustment get_vadjustment()
Return the vertical adjustment used to scroll the window
GTK.Vscrollbar get_vscrollbar()
The vertical scrollbar
int get_vscrollbar_policy()
One of POLICY_ALWAYS , POLICY_AUTOMATIC and POLICY_NEVER
int get_vscrollbar_visible()
1 if the vertical scrollbar is currently visible
int get_window_placement()
The location of the window relative to the scrollbars. One of CORNER_BOTTOM_LEFT , CORNER_BOTTOM_RIGHT , CORNER_TOP_LEFT and CORNER_TOP_RIGHT
GTK.ScrolledWindow set_hadjustment(GTK.Adjustment hadjustment)
Set the horizontal adjustment object
GTK.ScrolledWindow set_placement(int window_corner_placement)
The location of the window relative to the scrollbars. One of CORNER_BOTTOM_LEFT , CORNER_BOTTOM_RIGHT , CORNER_TOP_LEFT and CORNER_TOP_RIGHT
GTK.ScrolledWindow set_policy(int xpolicy, int ypolicy)
vertical and horiz policy. Both are one of POLICY_ALWAYS , POLICY_AUTOMATIC and POLICY_NEVER
GTK.ScrolledWindow set_vadjustment(GTK.Adjustment vadjustment)
Set the vertical adjustment object
| CLASS GTK.Paned |
GTK.Paned is the base class for widgets with two panes, arranged either horizontally (W(HPaned)) or vertically (W(VPaned)). Child widgets are added to the panes of the widget with pack1() and pack2(). The division beween the two children is set by default from the size requests of the children, but it can be adjusted by the user.
A paned widget draws a separator between the two child widgets and a small handle that the user can drag to adjust the division. It does not draw any relief around the children or around the separator. (The space in which the separator is called the gutter). Often, it is useful to put each child inside a W(Frame) with the shadow type set to GTK.ShadowIn so that the gutter appears as a ridge.
Each child has two options that can be set, resize and shrink. If resize is true, then when the GTK.Paned is resized, that child will expand or shrink along with the paned widget. If shrink is true, then when that child can be made smaller than it's requisition by the user. Setting shrink to 0 allows the application to set a minimum size. If resize is false for both children, then this is treated as if resize is true for both children.
The application can set the position of the slider as if it were set by the user, by calling set_position().
inherit GTK.Container : Container
GTK.Paned add1(GTK.Widget left_or_top)
Set the left or topmost item. This is equivalent to pack1(left_or_top,0,1)
GTK.Paned add2(GTK.Widget right_or_bottom)
Set the right or bottommost item This is equivalent to pack2(left_or_top,0,1)
int get_handle_size()
The size of the handle, in pixels
int get_handle_xpos()
The xpos of the handle, in pixels
int get_handle_ypos()
The ypos of the handle, in pixels
int get_in_drag()
Return 1 if the user is dragging the handle
int get_max_position()
The maximum handle position possible.
int get_min_position()
The minimum handle position possible.
GTK.Paned pack1(GTK.Widget widget, int resize, int shrink)
Add a child to the top or left pane.
GTK.Paned pack2(GTK.Widget widget, int resize, int shrink)
Add a child to the bottom or right pane.
GTK.Paned set_gutter_size(int gsize)
Set the width of the gutter. (The area between the two panes).
GTK.Paned set_handle_size(int hsize)
The size of the handle in pixels
GTK.Paned set_position(int position)
Set the position of the separator, as if set by the user. If position is negative, the remembered position is forgotten, and the division is recomputed from the the requisitions of the children.
| CLASS GTK.Arrow |
An arrow pointing in one of four directions. The 'etched' shadow
types does not work.
GTK.Arrow(GTK.ARROW_UP, GTK.SHADOW_OUT)
![]()
GTK.Arrow(GTK.ARROW_LEFT, GTK.SHADOW_IN)
![]()
GTK.Arrow(GTK.ARROW_RIGHT, GTK.SHADOW_IN)
![]()
GTK.Arrow(GTK.ARROW_DOWN, GTK.SHADOW_OUT)
![]()
inherit GTK.Misc : Misc
GTK.Arrow GTK.Arrow(int arrow_type, int shadow_type)
First argument is one of ARROW_DOWN , ARROW_LEFT , ARROW_RIGHT and ARROW_UP , second one of SHADOW_ETCHED_IN , SHADOW_ETCHED_OUT , SHADOW_IN , SHADOW_NONE and SHADOW_OUT .
int get_arrow_type()
Return the arrow type. One of ARROW_DOWN , ARROW_LEFT , ARROW_RIGHT and ARROW_UP .
int get_shadow_type()
Return the shadow type. One of SHADOW_ETCHED_IN , SHADOW_ETCHED_OUT , SHADOW_IN , SHADOW_NONE and SHADOW_OUT .
GTK.Arrow set(int arrow_type, int shadow_type)
First argument is one of ARROW_DOWN , ARROW_LEFT , ARROW_RIGHT and ARROW_UP , second one of SHADOW_ETCHED_IN , SHADOW_ETCHED_OUT , SHADOW_IN , SHADOW_NONE and SHADOW_OUT .
| CLASS GTK.MenuShell |
A GTK.MenuShell is the abstract base class used to derive the W(Menu) and W(MenuBar) subclasses.
A GTK.MenuShell is a container of W(MenuItem) objects arranged in a list which can be navigated, selected, and activated by the user to perform application functions. A W(MenuItem) can have a submenu associated with it, allowing for nested hierarchical menus.
Signals: activate_current An action signal that activates the current menu item within the menu shell.
cancel An action signal which cancels the selection within the menu shell. Causes the selection_done signal to be emitted.
deactivate This signal is emitted when a menu shell is deactivated.
move_current An action signal which moves the current menu item in the direction specified by the third argument.
selection_done This signal is emitted when a selection has been completed within a menu shell.
inherit GTK.Container : Container
GTK.MenuShell activate_item(GTK.Widget menu_item, int force_deactivate)
Activates the menu item within the menu shell.
GTK.MenuShell append(GTK.Widget what)
Adds a new W(MenuItem) to the end of the menu shell's item list. Same as 'add'.
array children()
This function returns all children of the menushell as an array.
GTK.MenuShell deactivate()
Deactivates the menu shell. Typically this results in the menu shell being erased from the screen.
int get_active()
1 if the menu shell is currently active.
GTK.MenuShell insert(GTK.Widget what, int where)
Add a widget after the specified location
GTK.MenuShell prepend(GTK.Widget what)
Add a menu item to the start of the widget (for a menu: top, for a bar: left)
GTK.MenuShell select_item(GTK.Widget menuitem)
Selects the menu item from the menu shell.
| CLASS GTK.ProgressBar |
A simple progress bar. Useful when you are doing things that take a long
time. Try to always have an 'abort' button whenever it makes sence.
GTK.ProgressBar()->update(0.1)
![]()
GTK.ProgressBar()->set_show_text(1)->update(0.3)
![]()
GTK.ProgressBar()->update(0.6)
![]()
GTK.ProgressBar()->update(1.0)
![]()
inherit GTK.Progress : Progress
GTK.ProgressBar GTK.ProgressBar()
Create a new progress bar. The default values are: Min 0.0, max 1.0, current 0.0
int get_activity_blocks()
The number of blocks that are set.
int get_activity_dir()
The current direction of the progress meter. 1 is forward and 0 is backwards. Usefull if you for some strange reason would like to know in what direction the activity indicator is swinging right now...
int get_activity_pos()
The position of the progress meter in pixels.
int get_activity_step()
The step size of the activity indicator in pixels.
int get_bar_style()
The progress bar style. GTK_PROGRESS_CONTINUOUS or GTK_PROGRESS_DISCRETE.
int get_blocks()
The total number of blocks.
int get_orientation()
The current orientation. GTK_PROGRESS_LEFT_TO_RIGHT, GTK_PROGRESS_RIGHT_TO_LEFT, GTK_PROGRESS_BOTTOM_TO_TOP or GTK_PROGRESS_TOP_TO_BOTTOM.
GTK.ProgressBar set_activity_blocks(int blocks)
The number of activity blocks
GTK.ProgressBar set_activity_step(int stepp)
Include activity blocks (empty gaps in the progressbar, ala windows 98)
GTK.ProgressBar set_bar_style(int style)
One of GTK.ProgressContinuous or GTK.ProgressDiscrete
GTK.ProgressBar set_discrete_blocks(int blocks)
The number of discrete blocks in the progress bar
GTK.ProgressBar set_orientation(int style)
One of GTK.ProgressLeftToRight, GTK.ProgressRightToLeft, GTK.ProgressBottomToTop or GTK.ProgressTopToBottom
GTK.ProgressBar update(float fraction)
0.0 is the minimum value, 1.0 is the maximum value.
| CLASS GTK.Box |
A box is a container that can contain more than one child. The basic 'Box' class cannot be instantiated, it is a virtual class that only defines some common 'Box' functions shared with all other Box widgets.
inherit GTK.Container : Container
GTK.Box pack_end(GTK.Widget widget, int expandp, int fillp, int padding)
Pack from the right (or bottom) of the box. Arguments are widget, expand, fill, paddingb widget, expand, fill, padding
GTK.Box pack_end_defaults(GTK.Widget widget)
The argument is the widget to add.
GTK.Box pack_start(GTK.Widget widget, int expandp, int fillp, int padding)
Pack from the left (or top) of the box. Argument are widget, expand, fill, padding pack(widget,1,1,0) is equivalent to 'add' or 'pack_start_defaults'
GTK.Box pack_start_defaults(GTK.Widget widget)
The argument is the widget to add. This function is equivalent to 'add'
mapping query_child_packing(GTK.Widget child)
Return a mapping: ([ "expand":expandp, "fill":fillp, "padding":paddingp, "type":type ])
GTK.Box reorder_child(GTK.Widget child, int new_position)
Move widget to pos, pos is an integer, between 0 and sizeof(box->children())-1
GTK.Box set_child_packing(GTK.Widget child_widget, int expandp, int fillp, int padding, int pack_type)
widget, expand, fill, padding, pack_type. If exand is true, the widget will be expanded when the box is resized. If 'fill' is true, the widget will be resized to fill up all available space. Padding is the amount of padding to use, and pack_type is one of PACK_END , PACK_EXPAND and PACK_START .
You can emulate pack_start and pack_end with add and set_child_packing.
GTK.Box set_homogeneous(int homogeneousp)
If true, all widgets in the box will get exactly the same amount of space
GTK.Box set_spacing(int spacing)
This is the amount of spacing (in pixels) inserted beween all widgets
| CLASS GTK.Fixed |
A fixed container is a container that keeps it's children at fixed locations and give them fixed sizes, both given in pixels.
Example:
GTK.Fixed()->put(GTK.Label("100,100"), 100, 100)->put(GTK.Label("0,0"), 0, 0)->set_usize(150,115)

inherit GTK.Container : Container
GTK.Fixed GTK.Fixed()
Create a new fixed widget
GTK.Fixed move(GTK.Widget widget, int new_xpos, int new_ypos)
Move the widget to new_xpos,new_ypos from it's old location.
GTK.Fixed put(GTK.Widget widget, int x, int y)
Place the widget at xpos,ypos.
| CLASS GTK.Item |
This class is inherited by all 'item' type of widgets.
Signals: deselect
select
toggle
inherit GTK.Bin : Bin
GTK.Item deselect()
Emulate a 'deselect' event.
GTK.Item select()
Emulate a 'select' event.
GTK.Item toggle()
Emulate a 'toggle' event.
| CLASS GTK.Range |
The category of range widgets includes the ubiquitous scrollbar widget and the less common "scale" widget. Though these two types of widgets are generally used for different purposes, they are quite similar in function and implementation. All range widgets share a set of common graphic elements, each of which has its own X window and receives events. They all contain a "trough" and a "slider" (what is sometimes called a "thumbwheel" in other GUI environments). Dragging the slider with the pointer moves it back and forth within the trough, while clicking in the trough advances the slider towards the location of the click, either completely, or by a designated amount, depending on which mouse button is used.
As mentioned in the W(Adjustment) page, all range widgets are associated with an adjustment object, from which they calculate the length of the slider and its position within the trough. When the user manipulates the slider, the range widget will change the value of the adjustment.
All of the GTK range widgets react to mouse clicks in more or less the same way. Clicking button-1 in the trough will cause its adjustment's page_increment to be added or subtracted from its value, and the slider to be moved accordingly. Clicking mouse button-2 in the trough will jump the slider to the point at which the button was clicked. Clicking any button on a scrollbar's arrows will cause its adjustment's value to change step_increment at a time.
It may take a little while to get used to, but by default, scrollbars as well as scale widgets can take the keyboard focus in GTK. If you think your users will find this too confusing, you can always disable this by unsetting the GTK.CanFocus flag on the scrollbar, like this:
scrollbar->unset_flag( GTK.CanFocus );
The key bindings (which are, of course, only active when the widget has focus) are slightly different between horizontal and vertical range widgets, for obvious reasons. They are also not quite the same for scale widgets as they are for scrollbars, for somewhat less obvious reasons (possibly to avoid confusion between the keys for horizontal and vertical scrollbars in scrolled windows, where both operate on the same area).
inherit GTK.Widget : Widget
GTK.Adjustment get_adjustment()
int get_button()
int get_click_child()
int get_digits()
int get_in_child()
int get_need_timer()
float get_old_lower()
float get_old_page_size()
float get_old_upper()
float get_old_value()
int get_policy()
int get_scroll_type()
int get_timer()
int get_x_click_point()
int get_y_click_point()
GTK.Range set_adjustment(GTK.Adjustment pos)
set_adjustment() does absolutely nothing if you pass it the adjustment that range is already using, regardless of whether you changed any of its fields or not. If you pass it a new Adjustment, it will unreference the old one if it exists (possibly destroying it), connect the appropriate signals to the new one, and call the private function gtk_range_adjustment_changed(), which will (or at least, is supposed to...) recalculate the size and/or position of the slider and redraw if necessary.
GTK.Range set_update_policy(int when)
The "update policy" of a range widget defines at what points during user interaction it will change the value field of its Adjustment and emit the "value_changed" signal on this Adjustment. The update policies are:
This is the default. The "value_changed" signal is emitted continuously, i.e., whenever the slider is moved by even the tiniest amount.
The "value_changed" signal is only emitted once the slider has stopped moving and the user has released the mouse button.
The "value_changed" signal is emitted when the user releases the mouse button, or if the slider stops moving for a short period of time.
GTK.Range slider_update()
Update the slider values.
| CLASS GTK.Hbox |
Most packing is done by creating boxes. These are invisible widget containers that we can pack our widgets into which come in two forms, a horizontal box, and a vertical box. This is the horizontal one. When packing widgets into a horizontal box, the objects are inserted horizontally from left to right or right to left depending on the call used.
GTK.Hbox(0,0)->add(GTK.Button("Hello"))->add(GTK.Button("World"))->pack_end_defaults(GTK.Button("From right"))->pack_start_defaults(GTK.Button("From left"))
![]()
GTK.Hbox(1,0)->add(GTK.Button("Hello"))->add(GTK.Button("World"))->pack_end_defaults(GTK.Button("From right"))->pack_start_defaults(GTK.Button("From left"))
![]()
GTK.Hbox(1,40)->add(GTK.Button("Hello"))->add(GTK.Button("World"))->pack_end_defaults(GTK.Button("From right"))->pack_start_defaults(GTK.Button("From left"))
![]()
inherit GTK.Box : Box
GTK.Hbox GTK.Hbox(int all_same_size, int hpadding)
Create a new horizontal box widget. If all_same_size is true, all widgets will have exactly the same size. hpadding is added to the left and right of the children.
| CLASS GTK.VbuttonBox |
A Vbutton_box is very similar to a Vbox. The major diffference is that the button box is made to pack buttons in, and has a few convenience function for normal button layouts.
GTK.VbuttonBox()->add(GTK.Button("Hello"))->add(GTK.Button("World"))->set_usize(100,300)

GTK.VbuttonBox()->add(GTK.Button("Hello"))->add(GTK.Button("World"))->set_layout(GTK.BUTTONBOX_SPREAD)->set_usize(100,300)

GTK.VbuttonBox()->add(GTK.Button("Hello"))->add(GTK.Button("World"))->set_layout(GTK.BUTTONBOX_EDGE)->set_usize(100,300)

GTK.VbuttonBox()->add(GTK.Button("Hello"))->add(GTK.Button("World"))->set_layout(GTK.BUTTONBOX_START)->set_usize(100,300)

GTK.VbuttonBox()->add(GTK.Button("Hello"))->add(GTK.Button("World"))->set_layout(GTK.BUTTONBOX_END)->set_usize(100,300)

inherit GTK.ButtonBox : ButtonBox
GTK.VbuttonBox GTK.VbuttonBox()
Create a new vertical button box
| CLASS GTK.TearoffMenuItem |
a GTK.TearoffMenuItem is a special W(MenuItem) which is used to tear off and reattach its menu.
When its menu is shown normally, the GTK.TearoffMenuItem is drawn as a dotted line indicating that the menu can be torn off. Activating it causes its menu to be torn off and displayed in its own window as a tearoff menu.
When its menu is shown as a tearoff menu, the GTK.TearoffMenuItem
is drawn as a dotted line which has a left pointing arrow graphic
indicating that the tearoff menu can be reattached. Activating it
will erase the tearoff menu window.
GTK.TearoffMenuItem()->set_usize( 100,0 )
![]()
inherit GTK.MenuItem : MenuItem
GTK.TearoffMenuItem GTK.TearoffMenuItem()
Create a new tear of menu item
int get_torn_off()
Return 1 if the menu the menu item is connected to is currently torn off.
| CLASS GTK.MenuItem |
Menu items, to be added to menues.
inherit GTK.Item : Item
GTK.MenuItem activate()
Emulate an activate signal
GTK.MenuItem configure(int toggle_indicator, int submenu_indicator)
First argument is 'show_toggle_indicator', second is 'show_submenu_indicator'.
GTK.MenuItem GTK.MenuItem(string|void label)
If a string is supplied, a W(Label) widget is created using that string and added to the item. Otherwise, you should add another widget to the list item with ->add().
GTK.MenuItem deselect()
Emulate a deselect signal
int get_accelerator_width()
The width of the accelerator string, in pixels
int get_right_justify()
Is the widget right justified?
int get_show_submenu_indicator()
Should the submenu indicator be shown?
int get_show_toggle_indicator()
Should the toggle indicator be shown?
int get_submenu_direction()
The direction the submenu will be shown in. One of DIR_DOWN , DIR_LEFT , DIR_RIGHT , DIR_TAB_BACKWARD , DIR_TAB_FORWARD and DIR_UP
int get_submenu_placement()
The placement of the submenu.
int get_toggle_size()
The size of the toggle indicator
GTK.MenuItem remove_submenu()
Remove the submenu for this menu button.
GTK.MenuItem right_justify()
Make the menu item stick to the right edge of it's container.
GTK.MenuItem select()
Emulate a select signal
GTK.MenuItem set_placement(int dir)
(sub menu placement) One of DIRECTION_LEFT and DIRECTION_RIGHT
GTK.MenuItem set_submenu(GTK.Widget menu)
Set the submenu for this menu button.
| CLASS GTK.AspectFrame |
A W(Frame) widget that always maintain a specified ratio between width and height. width/height == ratio
GTK.Aspect_frame("Title",0.5,0.5,0.4,0)->add( GTK.Label("Wrong aspect"))->set_usize(200,200)
![]()
inherit GTK.Frame : Frame
GTK.AspectFrame GTK.AspectFrame(string label, float xalign, float yalign, float ratio, int obey_child)
Create a new frame. Arguments are label, xalign, yalign, ratio, obey_child xalign is floats between 0 and 1, 0.0 is upper (or leftmost), 1.0 is lower (or rightmost). If 'obey_child' is true, the frame will use the aspect ratio of it's (one and only) child widget instead of 'ratio'.
GTK.AspectFrame set(float xalign, float yalign, float ratio, int obey_child)
Set the aspec values. Arguments are xalign, yalign, ratio, obey_child xalign is floats between 0 and 1, 0.0 is upper (or leftmost), 1.0 is lower (or rightmost). If 'obey_child' is true, the frame will use the aspect ratio of it's (one and only) child widget instead of 'ratio'.
| CLASS GTK.Scale |
The GTK.Scale widget is an abstract class, used only for deriving the subclasses GTK.Hscale and GTK.Vscale.
See W(Range) for generic range documentation
inherit GTK.Range : Range
int get_draw_value()
non-zero if the scale's current value is displayed next to the slider.
int get_value_pos()
The position in which the textual value is displayed, selected from POS_BOTTOM , POS_LEFT , POS_RIGHT and POS_TOP
int get_value_width()
An internal function used to get the maximum width needed to display the value string. Not normaly used by applications.
GTK.Scale set_digits(int precision)
Sets the number of decimal places that are displayed in the value.
GTK.Scale set_draw_value(int drawp)
Specifies whether the current value is displayed as a string next to the slider.
GTK.Scale set_value_pos(int where)
Sets the position in which the current value is displayed. One of POS_BOTTOM , POS_LEFT , POS_RIGHT and POS_TOP
| CLASS GTK.Editable |
The GTK.Editable class is a base class for widgets for editing text, such as W(Entry) and W(Text). It cannot be instantiated by itself. The editable class contains functions for generically manipulating an editable widget, a large number of action signals used for key bindings, and several signals that an application can connect to to modify the behavior of a widget.
Signals: activate Indicates that the user has activated the widget in some fashion. Generally, this will be done with a keystroke. (The default binding for this action is Return for GTK.Entry and Control-Return for GTK.Text.
changed Called when the text in the edit area is changed
copy_clipboard An action signal. Causes the characters in the current selection to be copied to the clipboard.
cut_clipboard An action signal. Causes the characters in the current selection to be copied to the clipboard and then deleted from the widget.
delete_text This signal is emitted when text is deleted from the widget by the user. The default handler for this signal will normally be responsible for inserting the text, so by connecting to this signal and then stopping the signal with signal_emit_stop(), it is possible to modify the inserted text, or prevent it from being inserted entirely. The start_pos and end_pos parameters are interpreted as for delete_text()
insert_text This signal is emitted when text is inserted into the widget by the user. The default handler for this signal will normally be responsible for inserting the text, so by connecting to this signal and then stopping the signal with signal_emit_stop(), it is possible to modify the inserted text, or prevent it from being inserted entirely.
kill_char An action signal. Delete a single character.
kill_line An action signal. Delete a single line.
kill_word n action signal. Delete a single word.
move_cursor An action signal. Move the cursor position.
move_page An action signal. Move the cursor by pages.
move_to_column An action signal. Move the cursor to the given column.
move_to_row An action signal. Move the cursor to the given row.
move_word An action signal. Move the cursor by words.
paste_clipboard An action signal. Causes the contents of the clipboard to be pasted into the editable widget at the current cursor position.
set_editable Determines if the user can edit the text in the editable widget or not. This is meant to be overriden by child classes and should not generally be useful to applications.
inherit GTK.Widget : Widget
GTK.Editable copy_clipboard()
Causes the characters in the current selection to be copied to the clipboard.
GTK.Editable cut_clipboard()
Causes the characters in the current selection to be copied to the clipboard and then deleted from the widget.
GTK.Editable delete_selection()
Deletes the current contents of the widgets selection and disclaims the selection.
GTK.Editable delete_text(int start_pos, int end_pos)
Delete a sequence of characters. The characters that are deleted are those characters at positions from start_pos up to, but not including end_pos. If end_pos is negative, then the the characters deleted will be those characters from start_pos to the end of the text.
string get_chars(int start_pos, int end_pos)
Retrieves a sequence of characters. The characters that are retrieved are those characters at positions from start_pos up to, but not including end_pos. If end_pos is negative, then the the characters retrieved will be those characters from start_pos to the end of the text.
int get_position()
Returns the cursor position
GTK.Editable insert_text(string text, int num_chars, int where)
Insert 'num_chars' characters from the text at the position 'where'.
GTK.Editable paste_clipboard()
Causes the contents of the clipboard to be pasted into the given widget at the current cursor position.
GTK.Editable select_region(int start_pos, int end_pos)
Selects a region of text. The characters that are selected are those characters at positions from start_pos up to, but not including end_pos. If end_pos is negative, then the the characters selected will be those characters from start_pos to the end of the text. are
GTK.Editable set_editable(int editablep)
Determines if the user can edit the text in the editable widget or not.
GTK.Editable set_position(int pos)
Sets the cursor position.
| CLASS GTK.Hruler |
Ruler widgets are used to indicate the location of the mouse pointer in a given window. A window can have a vertical ruler spanning across the width and a horizontal ruler spanning down the height. A small triangular indicator on the ruler shows the exact location of the pointer relative to the ruler.
GTK.Hruler()->set_metric(GTK.PIXELS)->set_range(0.0,100.0,50.0,100.0)->draw_ticks()->draw_pos()->set_usize(300,30)
![]()
GTK.Hruler()->set_metric(GTK.CENTIMETERS)->set_range(0.0,100.0,50.0,100.0)->draw_ticks()->draw_pos()->set_usize(300,30)
![]()
GTK.Hruler()->set_usize(300,30)
![]()
inherit GTK.Ruler : Ruler
GTK.Hruler GTK.Hruler()
Used to create a new hruler widget.
| CLASS GTK.InputDialog |
This dialog is used to enable XInput devices. By default, no extension devices are enabled. We need a mechanism to allow users to enable and configure their extension devices. GTK provides the InputDialog widget to automate this process. The following procedure manages an InputDialog widget. It creates the dialog if it isn't present, and shows it otherwise.
GTK.InputDialog inputd;
void create_input_dialog ()
{
if (!inputd)
{
inputd = GTK.InputDialog();
inputd->close_button()->signal_connect("clicked",inputd->hide, 0);
inputd->save_button()->hide();
inputd->show();
}
else
inputd->show();
}
GTK.InputDialog()

Signals: disable_device his signal is emitted when the user changes the mode of a device from a GDK_MODE_SCREEN or GDK_MODE_WINDOW to GDK_MODE_ENABLED
enable_device This signal is emitted when the user changes the mode of a device from GDK_MODE_DISABLED to a GDK_MODE_SCREEN or GDK_MODE_WINDOW.
inherit GTK.Dialog : Dialog
GTK.InputDialog GTK.InputDialog()
Create a new input dialog window.
GTK.Button get_close_button()
The 'close' button of the dialog.
GTK.Button get_save_button()
The 'save' button of the dialog.
| CLASS GTK.SelectionData |
The data associated with a selection.
string data()
Returns the selection in the data. The return value is always a string, but the width can vary (8, 16 or 32 bits per character).
int format()
Returns the selction format. The format is the number of bits per character.
int length()
Return the size of the selection data, in bytes.
The size of the data in characters (as returned by data()) is not necessarily the same.
GDK.Atom selection()
The selection id, as a GDK(Atom).
GTK.SelectionData set(string data)
Store new data into a GtkSelectionData object. Should _only_ by called from a selection handler callback.
GDK.Atom target()
The target, as a GDK(Atom).
GDK.Atom type()
The selection type, as a GDK(Atom).
| CLASS GTK.SpinButton |
The Spin Button widget is generally used to allow the user to select a value from a range of numeric values. It consists of a text entry box with up and down arrow buttons attached to the side. Selecting one of the buttons causes the value to "spin" up and down the range of possible values. The entry box may also be edited directly to enter a specific value.
The Spin Button allows the value to have zero or a number of decimal places and to be incremented/decremented in configurable steps. The action of holding down one of the buttons optionally results in an acceleration of change in the value according to how long it is depressed.
The Spin Button uses an W(Adjustment) object to hold information about the range of values that the spin button can take.
The attributes of an W(Adjustment) are used by the Spin Button in the following way: <ul><li>value: initial value for the Spin Button</li> <li>lower: lower range value</li> <li>upper: upper range value</li> <li>step_increment: value to increment/decrement when pressing mouse button 1 on a button</li> <li>page_increment: value to increment/decrement when pressing mouse button 2 on a button</li> <li>page_size: unused</li> </ul>
The argument order for the W(Adjustment) constructor is: value, lower, upper, step_increment, page_increment, page_size
GTK.SpinButton( GTK.Adjustment(),0.1, 1 )->set_usize(60,20)
![]()
inherit GTK.Entry : Entry
GTK.SpinButton configure(GTK.Adjustment range, float climb_rate, int precision)
Adjustment (with the lower/upper/increse values), climb_rate and digits
GTK.SpinButton GTK.SpinButton(GTK.Adjustment range, float climb_rate, int precision)
The climb_rate argument take a value between 0.0 and 1.0 and indicates the amount of acceleration that the Spin Button has. The digits argument specifies the number of decimal places to which the value will be displayed.
float get_climb_rate()
The amount of acceleration that the Spin Button has. 0.0 is no accelleration and 1.0 is highest accelleration.
int get_digits()
The number of decimal places to which the value will be displayed.
int get_numeric()
If != 0 the user can not enter anything but numeric values.
int get_snap_to_ticks()
If != 0 the Spin Button will round the value to the nearest step_increment.
int get_update_policy()
The update policy. GTK_UPDATE_ALWAYS or GTK_UPDATE_IF_VALID.
float get_value_as_float()
The current value of a Spin Button can be retrieved as a float.
int get_value_as_int()
The current value of a Spin Button can be retrieved as a int.
int get_wrap()
If != 0 the Spin Button will wrap around between the upper and lower range values.
GTK.SpinButton set_adjustment(GTK.Adjustment range)
Set a new adjustment.
GTK.SpinButton set_digits(int precision)
Set the number of digits to show to the user.
GTK.SpinButton set_numeric(int numericp)
If true, it is a numeric value. This prevents a user from typing anything other than numeric values into the text box of a Spin Button
GTK.SpinButton set_shadow_type(int type)
Type is one of SHADOW_ETCHED_IN , SHADOW_ETCHED_OUT , SHADOW_IN , SHADOW_NONE and SHADOW_OUT
GTK.SpinButton set_snap_to_ticks(int snapp)
Set the Spin Button to round the value to the nearest step_increment, which is set within the Adjustment object used with the Spin Button
GTK.SpinButton set_update_policy(int policy)
The possible values of policy are either GTK.UpdateAlways or GTK.UpdateIfValid.
These policies affect the behavior of a Spin Button when parsing inserted text and syncing its value with the values of the Adjustment.
In the case of GTK.UpdateIfValid the Spin Button value only gets changed if the text input is a numeric value that is within the range specified by the Adjustment. Otherwise the text is reset to the current value.
In case of GTK.UpdateAlways errors are ignored while converting text into a numeric value.
GTK.SpinButton set_value(float to)
Set the value.
GTK.SpinButton set_wrap(int wrapp)
If true, the spin button will wrap from the lowest to the highest value, and the highest to the lowest.
GTK.SpinButton spin(int direction, float increment)
If you want to alter the value of a Spin Value relative to its current value, then this ffunction can be used.
The direction paramenter is one of SPIN_END , SPIN_HOME , SPIN_PAGE_BACKWARD , SPIN_PAGE_FORWARD , SPIN_STEP_BACKWARD , SPIN_STEP_FORWARD and SPIN_USER_DEFINED
GTK.SpinStepForward and GTK.SpinStepBackward change the value of the Spin Button by the amount specified by increment, unless increment is equal to 0, in which case the value is changed by the value of step_increment in theAdjustment.
GTK.SpinPageForward and GTK.SpinPageBackward simply alter the value of the Spin Button by increment.
GTK.SpinHome sets the value of the Spin Button to the bottom of the Adjustments range.
GTK.SpinEnd sets the value of the Spin Button to the top of the Adjustments range.
GTK.SpinUserDefined simply alters the value of the Spin Button by the specified amount.
GTK.SpinButton update()
Explicitly request that the Spin Button updates itself
| CLASS GTK.MenuBar |
Basically a horizontal W(Menu).
The menu image cannot be
grabbed automatically, but this is how you would create a menu all
in one line. This is not the recommended coding style.
GTK.MenuBar()->add(GTK.Menu_item("Menu")->set_submenu(GTK.Menu()->add(GTK.Menu_item("Sub")))->select()->activate())->add(GTK.Menu_item("Bar"))
![]()
inherit GTK.MenuShell : MenuShell
GTK.MenuBar append(GTK.Widget menu)
GTK.MenuBar GTK.MenuBar()
GTK.MenuBar insert(GTK.Widget menu, int position)
GTK.MenuBar prepend(GTK.Widget menu)
GTK.MenuBar set_shadow_type(int int)
| CLASS GTK.Text |
The Text widget allows multiple lines of text to be displayed and edited. It supports both multi-colored and multi-font text, allowing them to be mixed in any way we wish. It also has a wide set of key based text editing commands, which are compatible with Emacs.
The text widget supports full cut-and-paste facilities, including the use of double- and triple-click to select a word and a whole line, respectively.
Bugs:<ul> <li> You cannot add text to the widget before it is realized.</li> </ul>
GTK.Text(GTK.Adjustment(),GTK.Adjustment())

function_object(call_out(GTK.Text(GTK.Adjustment(),GTK.Adjustment())->set_text, 0, "Some text")[0])

function_object(call_out(GTK.Text(GTK.Adjustment(),GTK.Adjustment())->insert, 0, "Some text", 0, GDK.Color(255,255,0), GDK.Color(0,0,0))[0])

inherit GTK.Editable : Editable
GTK.Text backward_delete(int nchars)
Delete n characters backwards from the cursor position
GTK.Text GTK.Text(GTK.Adjustment xadjustment, GTK.Adjustment yadjustment)
Creates a new GTK.Text widget, initialized with the given Gtk.Adjustments. These pointers can be used to track the viewing position of the GTK.Text widget. Passing NULL to either or both of them will make the text widget create it's own. You can set these later with the function gtk_text_set_adjustment()
GTK.Text forward_delete(int nchars)
Delete n characters forward from the cursor position
GTK.Text freeze()
Freezes the widget which disallows redrawing of the widget until it is thawed. This is useful if a large number of changes are going to made to the text within the widget, reducing the amount of flicker seen by the user.
int get_length()
Returns the length of the all the text contained within the widget
int get_point()
Gets the current position of the cursor as the number of characters from the upper left corner of the GtkText widget.
string get_text()
Get the current contents of the text object.
GTK.Text insert(string text, GDK.Font font, GDK.Color bg, GDK.Color fg)
syntax: object insert(string what); OR object insert(string what, GDK.Font font, GDK.Color fg, GDK.Color bg); OR object insert(string what, 0, GDK.Color fg, GDK.Color bg); OR object insert(string what, 0, GDK.Color fg); OR object insert(string what, 0, 0, GDK.Color bg);
Insert new text, optionally with colors.
GTK.Text set_adjustments(GTK.Adjustment xadjustment, GTK.Adjustment yadjustment)
Change the adjustments (as supplied to the constructor) to other adjustments.
GTK.Text set_editable(int editablep)
If true, the user can change the text in the widget.
GTK.Text set_line_wrap(int linewrapp)
If true, the widget will automatically wrap the contents.
GTK.Text set_point(int point)
Sets the cursor at the given point. In this case a point constitutes the number of characters from the extreme upper left corner of the widget.
GTK.Text set_text(string to)
Set the text to the specified string.
GTK.Text set_word_wrap(int wordwrapp)
If true, the widget will automatically wrap the contents.
GTK.Text thaw()
unfreeze the widget.
| CLASS GTK.Curve |
GTK.Curve()
![]()
inherit GTK.DrawingArea : DrawingArea
GTK.Curve GTK.Curve()
array get_vector(int num_points)
GTK.Curve reset()
GTK.Curve set_curve_type(int type)
One of CURVE_TYPE_FREE , CURVE_TYPE_LINEAR and CURVE_TYPE_SPLINE ;
GTK.Curve set_gamma(float gamma)
GTK.Curve set_range(float min_x, float max_x, float min_y, float max_y)
GTK.Curve set_vector(int nelems, array curve)
| CLASS GTK.RadioMenuItem |
Exactly like W(RadioButton), but it is an menu item.
GTK.RadioMenuItem("Menu item")
![]()
inherit GTK.MenuItem : MenuItem
GTK.RadioMenuItem GTK.RadioMenuItem(string|void title, GTK.RadioMenuItem groupmember)
object GTK.RadioMenuItem(string title) - First button (with label) object GTK.RadioMenuItem()->add(widget) - First button (with widget) object GTK.RadioMenuItem(title, another_radio_button) - Second to n:th button (with title) object GTK.RadioMenuItem(0,another_radio_button)->add(widget) - Second to n:th button (with widget)
GTK.RadioMenuItem set_group(GTK.RadioMenuItem groupmember)
the argument is another radio menu item to whose group this button should be added to. It is prefereable to use the second argument to the constructor instead, but if you for some reason want to move the button to another group, use this function.
| CLASS GTK.Label |
A simple text label.
GTK.Label("A simple text label")
![]()
GTK.Label("Multi\nline text\nlabel here")
![]()
GTK.Label("Multi\nline text\nlabel here")->set_justify(GTK.JUSTIFY_LEFT)
![]()
GTK.Label("Multi\nline text\nlabel here")->set_justify(GTK.JUSTIFY_RIGHT)
![]()
inherit GTK.Misc : Misc
GTK.Label GTK.Label(string text)
Creates a new label.
int parse_uline(string uline_string)
Convenience function to set the text and pattern by parsing a string with embedded underscores, returns the appropriate key symbol for the accelerator.
GTK.Label set(string text)
DEPRECATED Compatibility function to set the text in the label. Use set_text. This function can dissapear in the future.
GTK.Label set_justify(int justify)
one of JUSTIFY_CENTER , JUSTIFY_FILL , JUSTIFY_LEFT and JUSTIFY_RIGHT
GTK.Label set_line_wrap(int wrapp)
Should the label autolinewrap?
GTK.Label set_pattern(string pattern_string)
A string with either spaces or underscores. It should be of the same length as the text.
When a character in the text has a matching _ in the pattern, the character in the label will be underlined.
GTK.Label set_text(string text)
Set the text in the label
| CLASS GTK.HandleBox |
The contents of a handle box can be 'dragged' out of the box by the user.
The contents will then be placed in a separate window.
GTK.HandleBox()->add(GTK.Label("The contents"))
![]()
Signals: child_attached Called when a new child is added to the box
child_detached Called when a child is removed from the box
inherit GTK.Bin : Bin
GTK.HandleBox GTK.HandleBox()
Create a new handle box widget.
int get_child_detached()
Is the child detatched?
int get_float_window_mapped()
Is the floating window mapped?
int get_handle_position()
The position of the handle. One of POS_BOTTOM , POS_LEFT , POS_RIGHT and POS_TOP
int get_in_drag()
1 if the window is beeing dragged around right now.
int get_shrink_on_detach()
True if the container should shrink when the child is detatched
int get_snap_edge()
The edge to snap to. One of POS_BOTTOM , POS_LEFT , POS_RIGHT and POS_TOP , or -1 for unset.
GTK.HandleBox set_handle_position(int pos)
The position of the handle. One of POS_BOTTOM , POS_LEFT , POS_RIGHT and POS_TOP
int set_set_shrink_on_detach()
True if the container should shrink when the child is detatched
GTK.HandleBox set_shadow_type(int shadow_type)
One of SHADOW_ETCHED_IN , SHADOW_ETCHED_OUT , SHADOW_IN , SHADOW_NONE and SHADOW_OUT
GTK.HandleBox set_snap_edge(int pos)
The edge to snap to. One of POS_BOTTOM , POS_LEFT , POS_RIGHT and POS_TOP , or -1 for unset.
| CLASS GTK.AccelLabel |
A label for accelerators.
inherit GTK.Label : Label
GTK.AccelLabel GTK.AccelLabel(string text)
int get_accel_width()
int refetch()
GTK.AccelLabel set_accel_widget(GTK.Widget accel_widget)
| CLASS GTK.Viewport |
This is a container that can be scrolled around, but it has no scrollbars.
You can connect scrollbars to it using the adjustment objects.
GTK.Viewport(GTK.Adjustment(),GTK.Adjustment())->set_usize(100,100)

GTK.Viewport(GTK.Adjustment(),GTK.Adjustment())->set_usize(100,100)->set_shadow_type(GTK.SHADOW_ETCHED_IN)

GTK.Viewport(GTK.Adjustment(),GTK.Adjustment())->set_usize(100,100)->add(GTK.Label("A label with a very long text on it, it will not fit"))->set_shadow_type(GTK.SHADOW_ETCHED_IN)

lambda(){ object a1;object v = GTK.Viewport(a1=GTK.Adjustment(),GTK.Adjustment())->set_usize(100,100)->add(GTK.Label("A label with a very long text on it, it will not fit"))->set_shadow_type(GTK.SHADOW_ETCHED_IN);call_out(a1->set_value,0,100.0);return v;}()

inherit GTK.Bin : Bin
GTK.Viewport GTK.Viewport(GTK.Adjustment xscroll, GTK.Adjustment yscroll)
Create a new viewport. The adjustments are used to select what part of the viewport to view to the user. They are normally connected to a scrollbar or something similar.
GTK.Adjustment get_hadjustment()
Return the current horizontal adjustment object
GTK.Adjustment get_vadjustment()
Return the current vertical adjustment object
GTK.Viewport set_hadjustment(GTK.Adjustment xscroll)
Set a new horizontal adjustment object.
GTK.Viewport set_shadow_type(int type)
Set the shadow style. One of SHADOW_ETCHED_IN , SHADOW_ETCHED_OUT , SHADOW_IN , SHADOW_NONE and SHADOW_OUT
GTK.Viewport set_vadjustment(GTK.Adjustment yscroll)
Set a new vertical adjustment object.
| CLASS GTK.Menu |
A GTK.Menu is a W(MenuShell) that implements a drop down menu consisting of a list of W(MenuItem) objects which can be navigated and activated by the user to perform application functions.
A GTK.Menu is most commonly dropped down by activating a W(MenuItem) in a W(MenuBar) or popped up by activating a W(MenuItem) in another GTK.Menu.
A GTK.Menu can also be popped up by activating a W(OptionMenu). Other composite widgets such as the W(Notebook) can pop up a GTK.Menu as well.
Applications can display a GTK.Menu as a popup menu by calling the popup() function. The example below shows how an application can pop up a menu when the 3rd mouse button is pressed.
GTK.Menu menu = create_menu();
GTK.Window window = create_window();
window->signal_connect( "button_press_event", lambda(GTK.Menu m,
GTK.Window w,
mapping e ) {
if( e->button == 3 )
menu->popup();
}, menu );
inherit GTK.MenuShell : MenuShell
GTK.Menu append(GTK.Widget widget)
Adds a new W(MenuItem) to the end of the menu's item list.
GTK.Menu attach_to_widget(GTK.Widget widget)
Attach the menu to a widget
GTK.Menu GTK.Menu()
Create a new GTK.Menu widget.
GTK.Menu detach()
Detaches the menu from the widget to which it had been attached.
GTK.Widget get_active()
Returns the selected menu item from the menu. This is used by the W(OptionMenu).
GTK.Widget get_attach_widget()
Returns the W(Widget) that the menu is attached to.
int get_torn_off()
return 1 if the menu is torn off.
GTK.Menu insert(GTK.Widget widget, int position)
Adds a new W(MenuItem) to the menu's item list at the position indicated by position.
GTK.Menu popdown()
Removes the menu from the screen.
GTK.Menu popup(int|void button_pressed_to_show_menu)
The default button is 3.
GTK.Menu prepend(GTK.Widget widget)
Adds a new W(MenuItem) to the start of the menu's item list.
GTK.Menu reorder_child(GTK.Widget menuitem, int pos)
Moves a W(MenuItem) to a new position within the GTK.Menu.
GTK.Menu reposition()
Repositions the menu according to its position function.
GTK.Menu set_accel_group(GTK.AccelGroup accelerators)
Set the W(AccelGroup) which holds global accelerators for the menu.
GTK.Menu set_active(int activep)
Selects the specified menu item within the menu. This is used by the W(OptionMenu).
GTK.Menu set_tearoff_state(int torn_off)
Changes the tearoff state of the menu. A menu is normally displayed as drop down menu which persists as long as the menu is active. It can also be displayed as a tearoff menu which persists until it is closed or reattached.
GTK.Menu set_title(string new_title)
Sets the title string for the menu. The title is displayed when the menu is shown as a tearoff menu.
| CLASS GTK.Dial |
This widget provides an analog dial widget, similar to, for
example, a physical volume control on a stereo. Dial values can be
changable or read-only for value reporting.
GTK.Dial( GTK.Adjustment() );

GTK.Dial( GTK.Adjustment(10.0) )->set_percentage(0.4);

inherit GTK.Widget : Widget
GTK.Dial GTK.Dial(GTK.Adjustment adjustment)
GTK.Adjustment get_adjustment()
float get_percentage()
Retrieves the current percentage held in the dial widget.
float get_value()
Retrieves the current value helt in the dial widget.
GTK.Dial set_adjustment(GTK.Adjustment pos)
set_adjustment() does absolutely nothing if you pass it the adjustment that range is already using, regardless of whether you changed any of its fields or not. If you pass it a new Adjustment, it will unreference the old one if it exists (possibly destroying it), connect the appropriate signals to the new one, and call the private function gtk_range_adjustment_changed(), which will (or at least, is supposed to...) recalculate the size and/or position of the slider and redraw if necessary.
GTK.Dial set_percentage(float percent)
Sets the GTK.Dial's value to percent of dial->adjustment->upper. The upper value is set when the GtkAdjustment is created.
GTK.Dial set_update_policy(int when)
The "update policy" of a range widget defines at what points during user interaction it will change the value field of its Adjustment and emit the "value_changed" signal on this Adjustment. The update policies are:
This is the default. The "value_changed" signal is emitted continuously, i.e., whenever the slider is moved by even the tiniest amount.
The "value_changed" signal is only emitted once the slider has stopped moving and the user has released the mouse button.
The "value_changed" signal is emitted when the user releases the mouse button, or if the slider stops moving for a short period of time.
float set_value(float to)
Sets the current value held in the GtkDial's adjustment object to value. Returns the new percentage of value to the adjustment's upper limit.
GTK.Dial set_view_only(int view_only)
Specifies whether or not the user is to be able to edit the value represented by the dial widget. If view_only is TRUE, the dial will be set to view-only mode, and the user will not be able to edit it. If view_only is FALSE, the user will be able to change the valuerepresented.
| CLASS GTK.Statusbar |
Statusbars are simple widgets used to display a text message. They keep a stack of the messages pushed onto them, so that popping the current message will re-display the previous text message.
In order to allow different parts of an application to use the same statusbar to display messages, the statusbar widget issues Context Identifiers which are used to identify different 'users'. The message on top of the stack is the one displayed, no matter what context it is in. Messages are stacked in last-in-first-out order, not context identifier order.
lambda() {object sb = GTK.Statusbar();int id = sb->get_context_id("test");sb->push(id,"A message");sb->push(id,"Another message");return sb;}()
![]()
lambda() {object sb = GTK.Statusbar();int id = sb->get_context_id("test");sb->push(id,"A message");sb->push(id,"Another message");sb->pop(id);return sb;}()
![]()
Signals: text_poped
text_pushed
inherit GTK.Hbox : Hbox
GTK.Statusbar GTK.Statusbar()
Create a new statusbar widget
int get_context_id(string context)
Create a new context id (or get the id of an old one). The argument is any string. The return value can be used for ->push() ->pop() and ->remove later on.
GTK.Statusbar pop(int context)
Remove the topmost message.
int push(int context, string data)
Push a message onto the statusbar. The return value is an id that can be passed to remove later on.
GTK.Statusbar remove(int context, int id)
Remove the specified message (the message id is the second argument).
| CLASS GTK.Image |
An image is a image object stored in client, not X server, memory. A pixmap, on the other hand, is a image object stored in the X-server. See GDK.Image and GDK.Pixmap.
GTK.Image( GDK.Image(0)->set(Image.Image(200,200)->test() ) );

inherit GTK.Misc : Misc
GTK.Image GTK.Image(GDK.Image image, GDK.Bitmap mask)
You can skip the mask. The mask is used to mask the drawing of the image on it's background. It will not make the container transparent, though. Use shape_combine_mask on the container with the mask for that.
mapping get()
Returns ([ "image":GDK.Image img, "mask":GDK.Bitmap mask ])
GTK.Image set(GDK.Image image, GDK.Bitmap mask)
Args: GDK.Image and GDK.Bitmap, respectively. You can skip the mask. The mask is used to mask the drawing of the image on it's background. It will not make the container transparent, though. Use shape_combine_mask on the container with the mask for that.
There is no need to call 'set' with the same GDK.Image again if you have modified the image. You must, however, use ->queue_draw() to redraw the image. Otherwise the old contens will be shown until an refresh of the widget is done for any other reason.
| CLASS GTK.Object |
The basic GTK class. All other GTK classes inherit this class. The only user-callable functions are the signal related ones.
Signals: destroy Called when the object is destroyed
GTK.Object destroy()
GTK.Object signal_block(mixed signal_id)
Temporarily block a signal handler. No signals will be received while the hander is blocked. See signal connect for more info.
mixed signal_connect(string signal, function callback, mixed|void callback_arg)
Connect a signal to a pike function. The function will be called with the last argument to this function as it's first argument (defaults to 0), the second argument is always the widget, any other arguments are the ones supplied by GTK.
The return value of this function can be used to remove a signal with signal_disconnect, and block and unblock the signal will signal_block and signal_unblock.
mixed signal_connect_new(string signal, function callback, mixed|void callback_arg)
Connect a signal to a pike function.
This function differs from the signal_connect function in how it calls the callback function.
The old interface:
void signal_handler( mixed my_arg, GTK.Object object,
mixed ... signal_arguments )
The new interface:
void signal_handler( mixed ... signal_arguments,
mixed my_arg, GTK.Object object )
The return value of this function can be used to remove a signal with signal_disconnect, and block and unblock the signal will signal_block and signal_unblock.
GTK.Object signal_disconnect(mixed signal_id)
Remove a signal formerly added by signal_connect. The argument is the return value of signal_connect(). See signal connect for more info.
GTK.Object signal_emit(string signal_name)
Halt the emit of the current named signal. Useful in signal handlers when you want to override the behaviour of some default signal handler (key press events, as an example) See signal_connect.
GTK.Object signal_unblock(mixed signal_id)
Unblock a formerly blocked signal handler. See signal_block and signal_connect for more info.
| CLASS GTK.Hseparator |
Simply creates a horizontal separator. No bells or whistles.
GTK.Hseparator()->set_usize(300,3)
![]()
inherit GTK.Separator : Separator
GTK.Hseparator GTK.Hseparator()
Used to create a new hseparator widget.
| CLASS GTK.FontSelectionDialog |
The GtkFontSelectionDialog widget is a dialog box for selecting a font.
To set the font which is initially selected, use set_font_name().
To get the selected font use get_font() or get_font_name().
To change the text which is shown in the preview area, use set_preview_text().
The base filter is not yet implemented in Pike GTK.
Filters can be used to limit the fonts shown. There are 2 filters in
the GtkFontSelectionDialog - a base filter and a user filter. The
base filter can not be changed by the user, so this can be used when
the user must choose from the restricted set of fonts (e.g. for a
terminal-type application you may want to force the user to select a
fixed-width font). The user filter can be changed or reset by the
user, by using the 'Reset Filter' button or changing the options on
the 'Filter' page of the dialog.
GTK.FontSelectionDialog("Select a font")

inherit GTK.Window : Window
GTK.FontSelectionDialog GTK.FontSelectionDialog(string title)
Create a new font selection dialog with the specified window title
GTK.Button get_apply_button()
The apply button
GTK.Button get_cancel_button()
The cancel button
GTK.FontSelection get_fontsel()
The W(FontSelection) widget
GTK.Button get_ok_button()
The ok button
| CLASS GTK.Toolbar |
Toolbars are usually used to group some number of widgets in order to simplify customization of their look and layout. Typically a toolbar consists of buttons with icons, labels and tooltips, but any other widget can also be put inside a toolbar. Finally, items can be arranged horizontally or vertically and buttons can be displayed with icons, labels, or both.
Examples:
lambda(){object t=GTK.Toolbar( GTK.ORIENTATION_HORIZONTAL, GTK.TOOLBAR_TEXT );t->append_item( "Button 1", "Tooltip 1", "", GTK.Frame(), lambda(){},0);t->append_space();t->append_item( "Button 2", "Tooltip 2", "", GTK.Frame(), lambda(){},0);t->append_item( "Button 3", "Tooltip 3", "", GTK.Frame(), lambda(){},0);t->append_space();t->append_item( "Button 4", "Tooltip 4", "", GTK.Frame(), lambda(){},0);t->append_item( "Button 5", "Tooltip 5", "", GTK.Frame(), lambda(){},0);return t;}()
![]()
lambda(){object t=GTK.Toolbar( GTK.ORIENTATION_VERTICAL, GTK.TOOLBAR_TEXT );t->append_item( "Button 1", "Tooltip 1", "", GTK.Frame(), lambda(){},0);t->append_space();t->append_item( "Button 2", "Tooltip 2", "", GTK.Frame(), lambda(){},0);t->append_item( "Button 3", "Tooltip 3", "", GTK.Frame(), lambda(){},0);t->append_space();t->append_item( "Button 4", "Tooltip 4", "", GTK.Frame(), lambda(){},0);t->append_item( "Button 5", "Tooltip 5", "", GTK.Frame(), lambda(){},0);return t;}()
![]()
lambda(){object i=GDK.Image()->set(Image.Image(20,20)->test());object t=GTK.Toolbar( GTK.ORIENTATION_HORIZONTAL, GTK.TOOLBAR_BOTH );t->append_item( "Button 1", "Tooltip 1", "", GTK.Image(i), lambda(){},0);t->append_space();t->append_item( "Button 2", "Tooltip 2", "", GTK.Image(i), lambda(){},0);t->append_item( "Button 3", "Tooltip 3", "", GTK.Image(i), lambda(){},0);t->append_space();t->append_item( "Button 4", "Tooltip 4", "", GTK.Image(i), lambda(){},0);t->append_item( "Button 5", "Tooltip 5", "", GTK.Image(i), lambda(){},0);return t;}()
![]()
Signals: orientation_changed
style_changed
inherit GTK.Container : Container
GTK.Toolbar append_item(string label, string tooltip, string prv, GTK.Widget icon, function clicked_cb, mixed clicked_arg)
Adds a new button to the start of the toolbar.
GTK.Toolbar append_space()
Adds a small space.
GTK.Toolbar append_widget(GTK.Widget widget, string tootip, string prv)
Append a custom widgets. Arguments are widget, tooltip, private
GTK.Toolbar GTK.Toolbar(int orientation, int style)
Orientation is one of ORIENTATION_HORIZONTAL and ORIENTATION_VERTICAL . Style is one of TOOLBAR_BOTH , TOOLBAR_ICONS and TOOLBAR_TEXT
int get_button_relief()
GTK.Toolbar insert_item(string label, string tooltip, string prv, GTK.Widget icon, function clicked_cb, mixed clicked_arg, int position)
Arguments as for append_item, but an extra position argument at the end. Adds a new button after the item at the specified position.
GTK.Toolbar insert_space(int pixels)
Inserts a small space at the specified postion.
GTK.Toolbar insert_widget(GTK.Widget widget, string tootip, string prv, int pos)
Insert a custom widgets.
GTK.Toolbar prepend_item(string label, string tooltip, string prv, GTK.Widget icon, function clicked_cb, mixed clicked_arg)
Arguments as for append_item Adds a new button to the end of the toolbar.
GTK.Toolbar prepend_space()
Adds a small space.
GTK.Toolbar prepend_widget(GTK.Widget widget, string tootip, string prv)
Prepend a custom widgets. Arguments are widget, tooltip, private
GTK.Toolbar set_button_relief(int relief)
GTK.Toolbar set_orientation(int orientation)
Set the orientation, one of ORIENTATION_HORIZONTAL and ORIENTATION_VERTICAL
GTK.Toolbar set_space_size(int pixels)
Set the width (or height) of the space created by append_space.
GTK.Toolbar set_space_style(int style)
GTK.Toolbar set_style(int style)
Set the style, one of TOOLBAR_BOTH , TOOLBAR_ICONS and TOOLBAR_TEXT
GTK.Toolbar set_tooltips(int tootipp)
If true, show the tooltips.
| CLASS GTK.DrawingArea |
The drawing area is a window you can draw in.
Please note that you must handle refresh and resize events
on your own. Use W(pDrawingArea) for a drawingarea with automatic
refresh/resize handling.
GTK.DrawingArea()->set_usize(100,100)

inherit GTK.Widget : Widget
GTK.DrawingArea clear(int|void x, int|void y, int|void width, int|void height)
Either clears the rectangle defined by the arguments, of if no arguments are specified, the whole drawable.
GTK.DrawingArea copy_area(GDK.GC gc, int xdest, int ydest, GTK.Widget source, int xsource, int ysource, int width, int height)
Copies the rectangle defined by xsource,ysource and width,height from the source drawable, and places the results at xdest,ydest in the drawable in which this function is called.
GTK.DrawingArea GTK.DrawingArea()
GTK.DrawingArea draw_arc(GDK.GC gc, int filledp, int x1, int y1, int x2, int y2, int angle1, int angle2)
Draws a single circular or elliptical arc. Each arc is specified by a rectangle and two angles. The center of the circle or ellipse is the center of the rectangle, and the major and minor axes are specified by the width and height. Positive angles indicate counterclockwise motion, and negative angles indicate clockwise motion. If the magnitude of angle2 is greater than 360 degrees, it is truncated to 360 degrees.
GTK.DrawingArea draw_bitmap(GDK.GC gc, GDK.Bitmap bitmap, int xsrc, int ysrc, int xdest, int ydest, int width, int height)
Draw a GDK(Bitmap) in this drawable. NOTE: This drawable must be a bitmap as well. This will be fixed in GTK 1.3
GTK.DrawingArea draw_image(GDK.GC gc, GDK.Image image, int xsrc, int ysrc, int xdest, int ydest, int width, int height)
Draw the rectangle specified by xsrc,ysrc+width,height from the GDK(Image) at xdest,ydest in the destination drawable
GTK.DrawingArea draw_line(GDK.GC gc, int x1, int y1, int x2, int y2)
img_begin w = GTK.DrawingArea()->set_usize(100,100); delay: g = GDK.GC(w)->set_foreground( GDK.Color(255,0,0) ); delay: for(int x = 0; x<10; x++) w->draw_line(g,x*10,0,100-x*10,99); img_end
GTK.DrawingArea draw_pixmap(GDK.GC gc, GDK.Pixmap pixmap, int xsrc, int ysrc, int xdest, int ydest, int width, int height)
Draw the rectangle specified by xsrc,ysrc+width,height from the GDK(Pixmap) at xdest,ydest in the destination drawable
GTK.DrawingArea draw_point(GDK.GC gc, int x, int y)
img_begin w = GTK.DrawingArea()->set_usize(10,10); delay: g = GDK.GC(w)->set_foreground( GDK.Color(255,0,0) ); delay: for(int x = 0; x<10; x++) w->draw_point(g, x, x); img_end
GTK.DrawingArea draw_rectangle(GDK.GC gc, int filledp, int x1, int y1, int x2, int y2)
img_begin w = GTK.DrawingArea()->set_usize(100,100); delay: g = GDK.GC(w)->set_foreground( GDK.Color(255,0,0) ); delay: for(int x = 0; x<10; x++) w->draw_rectangle(g,0,x*10,0,100-x*10,99); img_end img_begin w = GTK.DrawingArea()->set_usize(100,100); delay: g = GDK.GC(w); delay: for(int x = 0; x<30; x++) { delay: g->set_foreground(GDK.Color(random(255),random(255),random(255)) ); delay: w->draw_rectangle(g,1,x*10,0,100-x*10,99); delay: } img_end
GTK.DrawingArea draw_text(GDK.GC gc, GDK.Font font, int x, int y, string text, int forcewide)
y is used as the baseline for the text. If forcewide is true, the string will be expanded to a wide string even if it is not already one. This is useful when writing text using either unicode or some other 16 bit font.
GTK.DrawingArea size(int width, int height)
This function is OBSOLETE
| CLASS GTK.CTreeRow |
This class is deprecated.
GTK.CTreeNode get_children()
Return the first child
int get_expanded()
Return 1 if the node is expanded
int get_is_leaf()
Return 1 if the node is a leaf node
int get_level()
Return the level of this node (0 for root, 1 for a child of the root, etc)
GTK.CTreeNode get_parent()
Return the parent node of this node
| CLASS GTK.Layout |
inherit GTK.Container : Container
GTK.Layout GTK.Layout(GTK.Adjustment hadjustment, GTK.Adjustment vadjustment)
GTK.Layout freeze()
GTK.Adjustment get_hadjustment()
int get_height()
GTK.Adjustment get_vadjustment()
int get_width()
int get_xoffset()
int get_yoffset()
GTK.Layout move(GTK.Widget widget, int x, int y)
GTK.Layout put(GTK.Widget widget, int x, int y)
GTK.Layout set_hadjustment(GTK.Adjustment adj)
GTK.Layout set_size(int xsize, int ysize)
GTK.Layout set_vadjustment(GTK.Adjustment adj)
GTK.Layout thaw()
| CLASS GTK.CTreeNode |
This is one of the nodes (branch or leaf) of the CTree. They are the equivalent of row numbers in a normal CList.
CTreeNode child()
Returns the first child node
int get_expanded()
Returns the previous sibling (the next on the same level)
int get_is_leaf()
Returns the previous sibling (the next on the same level)
int get_level()
Returns the previous sibling (the next on the same level)
CTreeNode next()
Returns the next sibling (the next on the same level)
GTK.CTreeNode parent()
Returns the parent node
CTreeNode prev()
Returns the previous sibling (the next on the same level)
GTK.CTreeRow row()
Returns the CTreeRow associated with this CTreeNode. DEPRECATED, all CTreeRow functions are also available directly in this object.
| CLASS GTK.AccelGroup |
An AccelGroup stores keybindings. A group is automatically created by W(MenuFactory)
NOIMG
inherit GTK.Data : Data
GTK.AccelGroup add_accel(GTK.Widget widget, string signal, int key, int modifiers, int flags)
the widget is the one in which the signal specified by 'signal' recides.
The key is the character code (such as 'a' for the a key and '@' for the @ key), and modifiers is a bitmap of one or more bits, the bits are . Flags is one or more of ACCEL_LOCKED , ACCEL_SIGNAL_VISIBLE and ACCEL_VISIBLE
GTK.AccelGroup GTK.AccelGroup()
Create a new accelerator group
GTK.AccelGroup destroy()
GTK.AccelGroup remove(GTK.Widget widget, int key, int modifiers)
Remove all bindings for the specified key/mask in the specified object.
| CLASS GTK.Container |
The basic container class.
Signals: add Called when a new object is added to the container. (used internally)
focus Called when the container gets focus (used internally)
need_resize Called when the container needs resizing (used internally)
remove Called when a object is removed from the container (used internally)
set_focus_child
inherit GTK.Widget : Widget
GTK.Container add(GTK.Widget widget)
Add a subwidget to the container. Don't forget to call show() in the subwidget. Some (even most) containers can only contain one child. Calling this function might result in a resize of the container.
GTK.Container border_width(int width)
Compatibility alias for set_border_width. Do not use this function in new code!
array children()
This function returns all children of the container as an array.
GTK.Container focus(int focus_direction)
Emulate a focus event. direction is one of DIR_DOWN , DIR_LEFT , DIR_RIGHT , DIR_TAB_BACKWARD , DIR_TAB_FORWARD and DIR_UP .
GTK.Container remove(GTK.Widget widget)
Remove a child from the container. The argument is the child to remove. Calling this function might result in a resize of the container.
GTK.Container set_border_width(int external_border_width)
Set the border width. The border width is the size of the padding around the container. Calling this function might result in a resize of the container.
GTK.Container set_focus_child(GTK.Widget child)
Emulate a set_focus_child signal. Focus on the specified child.
GTK.Container set_focus_hadjustment(GTK.Adjustment adj)
Set the hadjustment used to focus children.
GTK.Container set_focus_vadjustment(GTK.Adjustment adj)
Set the vadjustment used to focus children.
GTK.Container set_resize_mode(int mode)
One of RESIZE_IMMEDIATE , RESIZE_PARENT and RESIZE_QUEUE
| CLASS GTK.RadioButton |
Radio buttons are similar to check buttons except they are grouped so that only one may be selected/depressed at a time. This is good for places in your application where you need to select from a short list of options. To connect the buttons, use another button in the desired group as the second argument to GTK.RadioButton().
GTK.Radio_button("Button");
![]()
inherit GTK.CheckButton : CheckButton
GTK.RadioButton GTK.RadioButton(string|void title, GTK.RadioButton groupmember)
Normal creation: object GTK.RadioButton(string title) - First button (with label) object GTK.RadioButton()->add(widget) - First button (with widget) object GTK.RadioButton(title, another_radio_button) - Second to n:th button (with title) object GTK.RadioButton(0,another_radio_button)->add(widget) - Second to n:th button (with widget)
GTK.RadioButton set_group(GTK.RadioButton groupmember)
the argument is another radio button to whose group this button should be added to. It is prefereable to use the second argument to the constructor instead, but if you for some reason want to move the button to another group, use this function.
| CLASS GTK.Progress |
inherit GTK.Widget : Widget
GTK.Progress configure(float value, float min, float max)
Sets the current value, the minimum value and the maximum value. The default min and max are 0.0 and 1.0 respectively.
int get_activity_mode()
The currently set activity mode.
float get_current_percentage()
Returns a float between 0.0 and 1.0
string get_current_text()
Return the current text (see set_format_string)
string get_format()
The format used to convert the value to a the text
float get_percentage_from_value(float value)
Returns a float between 0.0 and 1.0
int get_show_text()
1 if the text will be shown
string get_text_from_value(float value)
Formats 'value' and returns it as a text.
float get_value()
Return the current value
<