class
	EV_GRID

General
	cluster: interface
	description: 
		"Widget which is a combination of an EV_TREE and an EV_MULTI_COLUMN_LIST.
		
		Item Insertion:
		
		The grid is an item holder for objects of type EV_GRID_ITEM and its descendents.  Each grid
		item may be inserted in to the grid at a specific column and row.  An item itself may be
		added to the grid via `set_item', which takes a column and row index.  Items be also added
		via the `set_item' routine of the row (EV_GRID_ROW) and column (EV_GRID_COLUMN) objects
		contained within `Current'.
		
		Items inserted may be Void if necessary, this may be useful to blank out any existing items
		set.
		
		If a grid contains no items and therefore has no rows or columns, inserting an item will
		dynamically resize and automatically create the columns and rows so that it can contain
		and display the newly inserted item. New columns and rows may also be added to the grid via
		`insert_new_column' and `insert_new_row' respectively.
		
		--------------------------------------------------------------------------------
		
		Dynamic Mode:
		
		There may be times where you have very large numbers of items you wish to
		display into the grid. Unfortunately, the overhead of building thousands and
		thousands of grid items and inserting them can take a considerable amount of
		which shows up as a delay to users of the system. To prevent this, the grid
		supports the use of a dynamic mode which permit you to specify how many items
		are contained and then as and when the grid requires access to one of these items
		for display purposes, an event is triggered requesting the item to be displayed.
		
		dynamic content is enabled via `enable_partial_dynamic_content'. In this mode
		whenever the grid attempts to draw an item that is `Void', it queries you for the
		item and then inserts it into the grid.
		
		The grid requests an item in the dynamic mode through the calling of the
		`dynamic_content_function' which may be set via a call to
		`set_dynamic_content_function'. This function has two integer arguments
		corresponding to the column and row index of the desired item and a return type
		of EV_GRID_ITEM.
		
		--------------------------------------------------------------------------------
		
		Size and Position:
		
		The grid is comprised of the following graphical elements:
		1. A header displayed at the top of `Current' which may be hidden/shown via
		`show_header' and hide_header'.
		2. A viewable area in which the contents of `Current' are displayed, displayed
		immediately below the header. The size of this
		area is given by `viewable_width' and `viewable_height' with its position
		relative to the top left corner of `Current' given by `viewable_x_offset',
		`viewable_y_offset'. Note that `viewable_y_offset' changes based on the visible
		state of the header.
		3. A horizontal scroll bar displayed below the viewable area, only shown if the
		virtual width of `Current' is greater than `viewable_width'.
		4. A vertical scroll bar displayed to the right of viewable area and header,
		only shown if the virtual height of `Current' is greater than `viewable_height'.
		
		You may supress the displaying of the scroll bars if required via calls to
		`hide_vertical_scroll_bar' and `hide_horizontal_scroll_bar' which ensure that
		the scroll bars are never displayed. This is useful for situations where you
		wish to control the virtual position of the grid via your own custom interface.
		
		The virtual size of the grid represents the complete screen area in pixels
		required to display the contents of `Current' and may be queried via
		`virtual_width' and `virtual_height'. If the contents of the grid are smaller
		than the viewable area, then the virtual size is equal to the viewable area,
		otherwise an area of the virtual size is displayed within viewable area, with
		the coordinates of this area (relative to the top left corner) within the
		virtual size given by `virtual_x' and `virtual_y'. As the scroll bars are moved,
		`virtual_x' and `virtual_y' are directly manipulated, although you may set the
		virtual position explicitly via calls to `set_virtual_x' and `set_virtual_y'.
		
		The maximum permitted virtual position of the grid is given by
		`maximum_virtual_x_position', `maximum_virtual_y_position' which is dependent on
		the following factors:
		The viewable area of the grid.
		The `virtual_width' and `virtual_height'.
		The `is_*_scrolling_per_item' properties.
		The `is_*_overscroll_enabled' properties.
		Changing one or more of these properties may immediately change the virtual width,
		height or maximum virtual positions, and possibly scroll the grid to ensure that the
		current virtual position is within the new bounds.
		
		The properties `is_vertical_overscroll_enabled' and `is_horizontal_overscroll_enabled'
		permit you to ensure the grid permits scrolling past the final item, ensuring that there
		is trailing space matching the viewable dimension of the grid less the dimension of
		the final item.
		
		You may query the virtual position of an item within the virtual area of
		`Current' via `virtual_x_position' and `virtual_y_position' directly on the
		item. You may also query the dimensions of an item via `width' and `height'. It
		is important to note that for an item that is part of a tree structure, the
		`width' may not be equal to `column.width' and the `virtual_x_position' may not
		be equal to `column.virtual_x_position'. This is because items in tree
		structures are indented to provide space for the expand/collapse icons as
		necessary. The number of pixels that the item is indented for this purpose may
		be queried directly from the item via a call
		to `horizontal_indent'.
		
		You may query the virtual y position of a row within `Current' via
		`virtual_y_position' directly on the row.
		You may query the virtual x position of a column within `Current' via
		`virtual_x_position' directly on the column.
		
		As items, columns or rows are added and removed from `Current', the virtual size
		may change. The virtual position may only change if in this situation, you are
		removing rows or columns that cause the virtual size to reduce and the virtual
		position is no longer valid. The grid will automatically adjust the virtua
		position so that the contents of the viewable area are completely contained
		within the new virtual position.
		
		The `height' of the rows displayed in `Current' is dependent on
		`is_row_height_fixed'. If `True',  then all rows are displayed at the same
		height, goverened by `row_height'. If `False', then the height of the row is
		goverened by its `height' property which may differ on an individual row basis.
		The width of columns is always unique and based on their `width' property.
		
		To determine if a particular item is located at a virtual position, use
		`item_at_virtual_position'. You may determine the first and last visible rows
		via `first_visible_row' and `last_visible_row', while `first_visible_column' and
		`last_visible_column' give the first and last columns visible in `Current'. For
		more precise information regarding exactly which rows and columns are displayed,
		you may query `visible_row_indexes' and `visible_column_indexes'. Note that if a
		tree is enabled via `enable_tree', then the contents of `visible_row_indexes'
		and `visible_column_indexes' may not be contiguous.
		
		To optimize performance, `Current'  only performs recomputation of the virtual
		positions of items as strictly necessary, which is normally once just before a
		redraw. As you may query virtual position information whenever you wish,
		`Current' may be forced to perform its recomputation of virtual positions as a
		result of your query. Each time that you modify something in the grid that may
		affect a virtual position of an item, the grid must recompute the virtual
		positions again as required. Therefore, for your code to be optimal, it may be
		necessary to take this into account. The worst possible case scenario is if you
		are to iterate from the start of the grid to the end of the grid and modify the
		state of each item or row during the iteration before querying a virtual position
		of an object in the grid past the current iteration position. In this situation,
		it is recommended that you perform a two-pass operation. First perform all of the
		modifications to the items and then perform all of the queries to virtual
		positions. The grid is optimized for additions in order so if you are repeatedly
		adding items and querying their virtual positions, then the performance is far
		better than if you are continuously inserting items at the start of the grid and
		querying their virtual positions. Although it is important to be aware of this
		behavior, you will find that in almost all cases, you have do perform no special
		optimizations to get good performance within `Current'. This also aplies to
		removal of rows. If you have many rows to remove, start with the final rows and
		iterate towards the first for increased performance.
		
		The re-drawing of `Current' is performed on idle, so if you are performing heavy
		computation and the grid is not updating, call `process_events' from
		EV_APPLICATION in order to force a re-draw.
		--------------------------------------------------------------------------------
		Appearance:
		
		Each of the items contained within the grid are sized based on the column and
		row that they occupy. If `is_row_height_fixed' is `True' then the height of the
		rows is dependent on `row_height' of `Current', otherwise it is dependent on
		`height' of the row and each row may occupy a different height. For the first
		non-`Void' item of each row, the position of the item is `item.horizontal_indent'
		pixels greater than the column in which it is contained. The appearance of each
		item is dependent on the actual type of the item, but there are a number of
		ways in which you may modify this at the grid level.
		
		`post_draw_overlay_function' is available, which permits you to draw directly on
		top of items immediately after they are dwan by the implementation. This is
		useful for adding custom borders to your items.
		`pre_draw_overlay_function' is available, which permits you to draw on top of the
		background of items, but before any features of that item have been drawn. For
		example, for grid label items, the background is cleared, then the function is
		called and then the `text' and `pixmap' are drawn. Note that for drawable items,
		which do not re-draw their background automatically, nothing is drawn before the
		`pre_draw_overlay_function' is called.
		
		When items are selected in a focused grid, they become highlighted in
		`focused_selection_color' and if the grid does not have the focus,
		`non_focused_selection_color' is used instead. It is recommended that you use
		these colors for your own drawable items to maintain consistency within the grid.
		The selection colors may be modified via `set_focused_selection_color' and
		`set_non_focused_selection_color'.
		
		Seperators between items may be enabled on the grid via `enable_column_separators'
		and `enable_row_separators' which ensure a single line is drawn between each row
		and column in `separator_color'. Use `set_separator_color' to modify this color.
		
		The tree structure of `Current' is drawn using `expand_node_pixmap' and
		`collapse_node_pixmap' to illustrate the expanded state of rows with subrows. You
		may use your own pixmaps by calling `set_expand_node_pixmap' and
		`set_collapse_node_pixmap'. The indent applied to each subrow is based on the
		current width of the node pixmaps + `subrow_indent'. You may increase this indent
		by calling `set_subrow_indent'. The nodes in the tree are connected via lines drawn
		in the color `tree_node_connector_color' which may be modified via
		`set_tree_node_connector_color'. These connecting lines may also be hidden via a
		call to `hide_tree_node_connectors'.
		
		During a column resize in `Current', the contents of the grid are immediately
		refreshed. This behavior may be disabled via a call to `disable_column_resize_immedite'
		and may be necessary if running the grid on older systems as it is less processor
		intensive. When not `is_column_resize_immediate', the column resizing is only performed
		when the user completes the resize, but a divider may be shown in `Current' which indicates
		its new width during the resizing, by calling `enable_resizing_divider'. This divider
		may be solid or dashed, based on the state of `is_resizing_divider_solid', settable via
		`enable_resizing_divider_solid' or `disable_resizing_divider_solid'.
		
		If you wish to perform multiple updates to the grid, in most cases the graphical
		update is buffered until the system becomes idle, thereby reducing flicker.
		However, in some situations, it is possible that the system may become idle
		during the updates, which may lead to flicker. In situations such as these, you
		may use `lock_update' to prevent graphical updates from occuring in the grid
		until `unlock_update' is called. While the grid `is_locked', no graphical updates
		of any form are performed.
		
		--------------------------------------------------------------------------------
		
		Selection:
		
		The grid allows both single and multiple selection handling on an item or row level.
		When enable_single_item_selection is called, only an single item may be selected by the
		user when `Current' is on-screen.  Selection may occur either programmatically via the
		`enable_select' routine of either the item/column or row or on-screen via mouse or keyboard.
		This is accompanied with the query `is_selected'.  When a user attempts to select an item or
		row on-screen the grid attempts to make that item or row more visible to the user so that the
		text of the item may be read, this will not occur however if the item is currently activated.
		
		There are two main selection modes, item selection and row selection.  In item selection,
		single or multiple items may be selected depending on the current selection mode.  This can be
		set with `enable_single_item_selection' and `enable_multiple_item_selection' respectively.
		
		For each type of selection there are events.  Examples of such events are `item_select_actions',
		`row_select_actions' and `column_select_actions', these are fired in `Current', with the
		appropriate object being passed to the action sequence that is selected. `item_select_actions'
		will only get executed whilst in either single or multiple item selection mode. For handling selection
		events during single or multiple row selection modes, `row_select_actions' should be used.
		To keep track of deselected items, rows or columns, there is `item_deselect_actions',
		`row_deselect_actions' and `column_deselect_actions' respectively.
		
		Along with selecting items, they may also be deselected.  This can be done programatically
		via the `disable_select' routine of either the item/column or row.
		
		To query what objects are selected, the following queries are available in `Current',
		`selected_items', `selected_rows' and `selected_columns'.
		
		To turn off any default behavior the following queries are available, `disable_selection_key_handling'
		and `disable_selection_click_handling', this turns off the ability for the user of the grid
		to select items via the keyboard or mouse.
		
		The routine `enable_always_selected' makes sure that at least one item or row is selected depending
		on the mode after the initial selection.  This can be handy for implementing widgets that require an item
		be selected at all times.
		
		The selection of the grid may be removed with `remove_selection'.
		
		--------------------------------------------------------------------------------
		
		Item Activation:
		
		Activation allows for interactive editing of the contents of an item. By calling
		`activate' on an activatable item in response to a user event such as double clicking,
		the item allows for in-place user editing, for changing things such as text.  After
		changing the item, the user may complete the activation by pressing Enter on the
		keyboard or by causing the item itself to loose focus.
		
		To programmatically cancel any activation, each grid item has a `deactivate' routine
		that may be called during the activation.
		
		If an activation occurs during a user selection then the grid itself will not attempt to reposition
		the item so that it is more visible.
		
		When an item is activated, the `item_activate_actions' are fired, this can be used
		to customize the activation process of a certain item, `item_deactivate_actions' are
		fired when the item is deactivated.  When an item is deactivated, if the user hasn't
		cancelled the deactivation then the item's contents are updated.
		
		See EV_GRID_EDITABLE_ITEM and EV_GRID_COMBO_ITEM for examples of activatable items
		that allow for in place editing.
		
		--------------------------------------------------------------------------------
		Event Handling:
		
		The standard set of widget events are inherited from EV_CELL with an additional
		set of events that are applicable to both `Current' and the items contained are
		inherited from EV_GRID_ACTION_SEQUENCES. For example,
		`pointer_button_press_actions' is inherited from EV_CELL, while
		`pointer_button_press_item_actions' is inherited from EV_GRID_ACTION_SEQUENCES
		and has an EV_GRID_ITEM as event data specifying the applicable item (if any).
		The coordinates of the item specific versions use virtual coordinates of
		`Current' as their coordinate information, wheras those inherited from EV_CELL
		use client coordinates as for any other EV_WIDGET. The order of event execution
		for multiple action sequences that may be triggered by a single event are as
		follows:
		1. The standard inherited widget events are fired. i.e.
		%"grid.pointer_button_press_actions%" The x and y coordinate event data is
		relative to the upper left corner of `Current'.
		2. The grid item specific versions of these events are fired. i.e.
		%"grid.pointer_button_press_item_actions%" The x and y coordinate event data is
		relative to the upper left corner of the %"item%" area of `Current', in virtual
		grid coordinates. These events are only fired while the mouse pointer is above
		the %"item%" area (does not include header and scroll bars).
		3. The events are fired on the item themselves. i.e.
		%"item.pointer_button_press_actions%" The x and y coordinate event data is
		relative to the upper left corner of the item.
		
		The grid specific versions of particular events permit you to perform handling
		for all of your items in a common place and are always fired before the specific
		item versions. For example, if you connect to both EV_GRID.row_expand_actions
		and EV_GRID_ROW.expand_actions, the grid version is fired first, immediately by
		the row version. The action sequences are fired one immediately after the other
		and both are always fired even if you change states of the target object within
		the first action sequence.
		--------------------------------------------------------------------------------
		
		Color Handling:
		
		Colors applied to items within `Current' are determined on a three level basis.
		The base level is `Current' whose `foreground_color' and `background_color' may
		never be Void.
		The second level are the columns and rows of `Current' whose `foreground_color'
		and `background_color' are `Void' by default.
		The final level is comprised of the items of `Current' themselves whose
		`foreground_color' and `background_color' are `Void' by default.
		As `Current' performs a  re-draw of an item %"cell%" contained within, the
		following rules are applied in order to determine the displayed colors:
		1. If there is an item in the %"cell%" which has a non-Void `foreground_color' or
		`background_color' then these colors are applied to the contents of that %"cell%",
		otherwise, step 2 is applied.
		2. If the column or row at that position has non-Void `foreground_color' or
		`background_color' then these colors are applied to the contents of that %"cell%",
		otherwise step 3 is applied.
		3. As the colors of the item, row and column were all `Void', the `foreground'
		and `background_color' of `Current' is applied to the contents of that %"cell%".
		Note that for areas of an items %"cell%" that are not filled by item item itself,
		such as the area of a tree structure, step 1 is ignored and the color
		calculations begin at step 2."

Ancestors
	EV_CELL
	EV_GRID_ACTION_SEQUENCES
	EV_GRID_TYPES
	EV_TOOLTIPABLE*
	REFACTORING_HELPER

Action sequences
	column_deselect_actions: ACTION_SEQUENCE [TUPLE [EV_GRID_COLUMN]]
	column_select_actions: ACTION_SEQUENCE [TUPLE [EV_GRID_COLUMN]]
	conforming_pick_actions: EV_NOTIFY_ACTION_SEQUENCE
	dock_ended_actions: EV_NOTIFY_ACTION_SEQUENCE
	dock_started_actions: EV_NOTIFY_ACTION_SEQUENCE
	docked_actions: EV_DOCKABLE_SOURCE_ACTION_SEQUENCE
	drop_actions: EV_PND_ACTION_SEQUENCE
	fill_background_actions: ACTION_SEQUENCE [TUPLE [EV_DRAWABLE, INTEGER_32, INTEGER_32, INTEGER_32, INTEGER_32]]
	focus_in_actions: EV_NOTIFY_ACTION_SEQUENCE
	focus_out_actions: EV_NOTIFY_ACTION_SEQUENCE
	item_activate_actions: ACTION_SEQUENCE [TUPLE [EV_GRID_ITEM, EV_POPUP_WINDOW]]
	item_deactivate_actions: EV_GRID_ITEM_ACTION_SEQUENCE
	item_deselect_actions: EV_GRID_ITEM_ACTION_SEQUENCE
	item_drop_actions: ACTION_SEQUENCE [TUPLE [EV_GRID_ITEM, ANY]]
	item_select_actions: EV_GRID_ITEM_ACTION_SEQUENCE
	key_press_actions: EV_KEY_ACTION_SEQUENCE
	key_press_string_actions: EV_KEY_STRING_ACTION_SEQUENCE
	key_release_actions: EV_KEY_ACTION_SEQUENCE
	mouse_wheel_actions: EV_INTEGER_ACTION_SEQUENCE
	pick_actions: EV_PND_START_ACTION_SEQUENCE
	pick_ended_actions: EV_PND_FINISHED_ACTION_SEQUENCE
	pointer_button_press_actions: EV_POINTER_BUTTON_ACTION_SEQUENCE
	pointer_button_press_item_actions: ACTION_SEQUENCE [TUPLE [INTEGER_32, INTEGER_32, INTEGER_32, EV_GRID_ITEM]]
	pointer_button_release_actions: EV_POINTER_BUTTON_ACTION_SEQUENCE
	pointer_button_release_item_actions: ACTION_SEQUENCE [TUPLE [INTEGER_32, INTEGER_32, INTEGER_32, EV_GRID_ITEM]]
	pointer_double_press_actions: EV_POINTER_BUTTON_ACTION_SEQUENCE
	pointer_double_press_item_actions: ACTION_SEQUENCE [TUPLE [INTEGER_32, INTEGER_32, INTEGER_32, EV_GRID_ITEM]]
	pointer_enter_actions: EV_NOTIFY_ACTION_SEQUENCE
	pointer_enter_item_actions: ACTION_SEQUENCE [TUPLE [BOOLEAN, EV_GRID_ITEM]]
	pointer_leave_actions: EV_NOTIFY_ACTION_SEQUENCE
	pointer_leave_item_actions: ACTION_SEQUENCE [TUPLE [BOOLEAN, EV_GRID_ITEM]]
	pointer_motion_actions: EV_POINTER_MOTION_ACTION_SEQUENCE
	pointer_motion_item_actions: ACTION_SEQUENCE [TUPLE [INTEGER_32, INTEGER_32, EV_GRID_ITEM]]
	post_draw_overlay_actions: ACTION_SEQUENCE [TUPLE [EV_DRAWABLE, EV_GRID_ITEM, INTEGER_32, INTEGER_32]]
	pre_draw_overlay_actions: ACTION_SEQUENCE [TUPLE [EV_DRAWABLE, EV_GRID_ITEM, INTEGER_32, INTEGER_32]]
	resize_actions: EV_GEOMETRY_ACTION_SEQUENCE
	row_collapse_actions: EV_GRID_ROW_ACTION_SEQUENCE
	row_deselect_actions: EV_GRID_ROW_ACTION_SEQUENCE
	row_expand_actions: EV_GRID_ROW_ACTION_SEQUENCE
	row_select_actions: EV_GRID_ROW_ACTION_SEQUENCE
	virtual_position_changed_actions: ACTION_SEQUENCE [TUPLE [INTEGER_32, INTEGER_32]]
	virtual_size_changed_actions: ACTION_SEQUENCE [TUPLE [INTEGER_32, INTEGER_32]]

Queries
	accept_cursor: EV_POINTER_STYLE
	activated_item: EV_GRID_ITEM
	actual_drop_target_agent: FUNCTION [ANY, TUPLE [INTEGER_32, INTEGER_32], EV_ABSTRACT_PICK_AND_DROPABLE]
	are_column_separators_enabled: BOOLEAN
	are_columns_drawn_above_rows: BOOLEAN
	are_columns_removable (a_index, n: INTEGER_32): BOOLEAN
	are_row_separators_enabled: BOOLEAN
	are_tree_node_connectors_shown: BOOLEAN
	background_color: EV_COLOR
	cell_background_pixmap: EV_PIXMAP
	cell_client_height: INTEGER_32
	cell_client_width: INTEGER_32
	cell_count: INTEGER_32
	cell_extendible: BOOLEAN
	cell_full: BOOLEAN
	cell_has (v: EV_WIDGET): BOOLEAN
	cell_has_recursive (an_item: [like cell_item] EV_WIDGET): BOOLEAN
	cell_is_empty: BOOLEAN
	cell_is_inserted (v: EV_WIDGET): BOOLEAN
	cell_is_parent_recursive (a_widget: EV_WIDGET): BOOLEAN
	cell_item: EV_WIDGET
	cell_linear_representation: LINEAR [[like cell_item] EV_WIDGET]
	cell_may_contain (v: EV_WIDGET): BOOLEAN
	cell_merged_radio_button_groups: ARRAYED_LIST [EV_CONTAINER]
	collapse_node_pixmap: EV_PIXMAP
	column (a_column: INTEGER_32): EV_GRID_COLUMN
	column_at_virtual_position (a_virtual_x: INTEGER_32): EV_GRID_COLUMN
	column_count: INTEGER_32
	column_displayed (a_column: INTEGER_32): BOOLEAN
	column_type: EV_GRID_COLUMN
	data: ANY
	default_key_processing_handler: PREDICATE [ANY, TUPLE [EV_KEY]]
	deny_cursor: EV_POINTER_STYLE
	displayed_column (i: INTEGER_32): EV_GRID_COLUMN
	displayed_column_count: INTEGER_32
	dynamic_content_function: FUNCTION [ANY, TUPLE [INTEGER_32, INTEGER_32], EV_GRID_ITEM]
	expand_node_pixmap: EV_PIXMAP
	first_visible_column: EV_GRID_COLUMN
	first_visible_row: EV_GRID_ROW
	focused_selection_color: EV_COLOR
	focused_selection_text_color: EV_COLOR
	foreground_color: EV_COLOR
	has_capture: BOOLEAN
	has_focus: BOOLEAN
	header: EV_GRID_HEADER
	height: INTEGER_32
	help_context: FUNCTION [ANY, TUPLE, EV_HELP_CONTEXT]
	highest_parent_row_within_bounds (lower_index, upper_index: INTEGER_32): EV_GRID_ROW
	horizontal_scroll_bar: EV_HORIZONTAL_SCROLL_BAR
	id_freed: BOOLEAN
	id_object (an_id: INTEGER_32): IDENTIFIED
	is_always_selected: BOOLEAN
	is_column_resize_immediate: BOOLEAN
	is_content_partially_dynamic: BOOLEAN
	is_destroyed: BOOLEAN
	is_displayed: BOOLEAN
	is_dockable: BOOLEAN
	is_docking_enabled: BOOLEAN
	is_external_docking_enabled: BOOLEAN
	is_external_docking_relative: BOOLEAN
	is_full_redraw_on_virtual_position_change_enabled: BOOLEAN
	is_header_displayed: BOOLEAN
	is_horizontal_overscroll_enabled: BOOLEAN
	is_horizontal_scroll_bar_show_requested: BOOLEAN
	is_horizontal_scrolling_per_item: BOOLEAN
	is_locked: BOOLEAN
	is_multiple_item_selection_enabled: BOOLEAN
	is_multiple_row_selection_enabled: BOOLEAN
	is_resizing_divider_enabled: BOOLEAN
	is_resizing_divider_solid: BOOLEAN
	is_row_height_fixed: BOOLEAN
	is_selection_keyboard_handling_enabled: BOOLEAN
	is_selection_on_click_enabled: BOOLEAN
	is_selection_on_single_button_click_enabled: BOOLEAN
	is_sensitive: BOOLEAN
	is_show_requested: BOOLEAN
	is_single_item_selection_enabled: BOOLEAN
	is_single_row_selection_enabled: BOOLEAN
	is_tree_enabled: BOOLEAN
	is_vertical_overscroll_enabled: BOOLEAN
	is_vertical_scroll_bar_show_requested: BOOLEAN
	is_vertical_scrolling_per_item: BOOLEAN
	item (a_column, a_row: INTEGER_32): EV_GRID_ITEM
	item_accept_cursor_function: FUNCTION [ANY, TUPLE [EV_GRID_ITEM], EV_POINTER_STYLE]
	item_at_virtual_position (a_virtual_x, a_virtual_y: INTEGER_32): EV_GRID_ITEM
	item_deny_cursor_function: FUNCTION [ANY, TUPLE [EV_GRID_ITEM], EV_POINTER_STYLE]
	item_pebble_function: FUNCTION [ANY, TUPLE [EV_GRID_ITEM], ANY]
	item_veto_pebble_function: FUNCTION [ANY, TUPLE [EV_GRID_ITEM, ANY], BOOLEAN]
	last_visible_column: EV_GRID_COLUMN
	last_visible_row: EV_GRID_ROW
	locked_columns: ARRAYED_LIST [EV_GRID_COLUMN]
	locked_rows: ARRAYED_LIST [EV_GRID_ROW]
	maximum_virtual_x_position: INTEGER_32
	maximum_virtual_y_position: INTEGER_32
	minimum_height: INTEGER_32
	minimum_width: INTEGER_32
	mode_is_drag_and_drop: BOOLEAN
	mode_is_pick_and_drop: BOOLEAN
	mode_is_target_menu: BOOLEAN
	non_focused_selection_color: EV_COLOR
	non_focused_selection_text_color: EV_COLOR
	object_id: INTEGER_32
	parent: EV_CONTAINER
	parent_of_source_allows_docking: BOOLEAN
	pebble: ANY
	pebble_function: FUNCTION [ANY, TUPLE, ANY]
	pebble_positioning_enabled: BOOLEAN
	pebble_x_position: INTEGER_32
	pebble_y_position: INTEGER_32
	pointer_position: EV_COORDINATE
	pointer_style: EV_POINTER_STYLE
	Prunable: BOOLEAN
	Readable: BOOLEAN
	real_source: EV_DOCKABLE_SOURCE
	real_target: EV_DOCKABLE_TARGET
	row (a_row: INTEGER_32): EV_GRID_ROW
	row_at_virtual_position (a_virtual_y: INTEGER_32; ignore_locked_rows: BOOLEAN): EV_GRID_ROW
	row_count: INTEGER_32
	row_height: INTEGER_32
	row_type: EV_GRID_ROW
	rows_may_be_moved (a_first_row_index, a_row_count: INTEGER_32): BOOLEAN
	screen_x: INTEGER_32
	screen_y: INTEGER_32
	selected_columns: ARRAYED_LIST [EV_GRID_COLUMN]
	selected_items: ARRAYED_LIST [EV_GRID_ITEM]
	selected_rows: ARRAYED_LIST [EV_GRID_ROW]
	separator_color: EV_COLOR
	source_has_current_recursive (source: EV_DOCKABLE_SOURCE): BOOLEAN
	subrow_indent: INTEGER_32
	target_name: STRING_GENERAL
	to_implement_assertion (comment: STRING_8): BOOLEAN
	tooltip: STRING_32
	tree_node_connector_color: EV_COLOR
	tree_node_spacing: INTEGER_32
	vertical_scroll_bar: EV_VERTICAL_SCROLL_BAR
	veto_dock_function: FUNCTION [ANY, TUPLE [EV_DOCKABLE_SOURCE], BOOLEAN]
	viewable_height: INTEGER_32
	viewable_row_indexes: ARRAYED_LIST [INTEGER_32]
	viewable_width: INTEGER_32
	viewable_x_offset: INTEGER_32
	viewable_y_offset: INTEGER_32
	virtual_height: INTEGER_32
	virtual_width: INTEGER_32
	virtual_x_position: INTEGER_32
	virtual_y_position: INTEGER_32
	visible_column_indexes: ARRAYED_LIST [INTEGER_32]
	visible_row_indexes: ARRAYED_LIST [INTEGER_32]
	width: INTEGER_32
	Writable: BOOLEAN
	x_position: INTEGER_32
	y_position: INTEGER_32

Commands
	cell_extend (v: [like cell_item] EV_WIDGET)
	cell_fill (other: CONTAINER [EV_WIDGET])
	cell_merge_radio_button_groups (other: EV_CONTAINER)
	cell_propagate_background_color
	cell_propagate_foreground_color
	cell_prune (v: EV_WIDGET)
	cell_prune_all (v: EV_WIDGET)
	cell_put (v: [like cell_item] EV_WIDGET)
	cell_replace (v: [like cell_item] EV_WIDGET)
	cell_unmerge_radio_button_groups (other: EV_CONTAINER)
	cell_wipe_out
	center_pointer
	clear
	copy (other: [like Current] EV_GRID)
	destroy
	disable_always_selected
	disable_capture
	disable_column_resize_immediate
	disable_column_separators
	disable_columns_drawn_above_rows
	disable_dockable
	disable_docking
	disable_dynamic_content
	disable_external_docking
	disable_external_docking_relative
	disable_full_redraw_on_virtual_position_change
	disable_horizontal_overscroll
	disable_horizontal_scrolling_per_item
	disable_pebble_positioning
	disable_resizing_divider
	disable_row_height_fixed
	disable_row_separators
	disable_selection_key_handling
	disable_selection_on_click
	disable_sensitive
	disable_solid_resizing_divider
	disable_tree
	disable_vertical_overscroll
	disable_vertical_scrolling_per_item
	enable_always_selected
	enable_capture
	enable_column_resize_immediate
	enable_column_separators
	enable_columns_drawn_above_rows
	enable_dockable
	enable_docking
	enable_external_docking
	enable_external_docking_relative
	enable_full_redraw_on_virtual_position_change
	enable_horizontal_overscroll
	enable_horizontal_scrolling_per_item
	enable_multiple_item_selection
	enable_multiple_row_selection
	enable_partial_dynamic_content
	enable_pebble_positioning
	enable_resizing_divider
	enable_row_height_fixed
	enable_row_separators
	enable_selection_key_handling
	enable_selection_on_click
	enable_selection_on_single_button_click
	enable_sensitive
	enable_single_item_selection
	enable_single_row_selection
	enable_solid_resizing_divider
	enable_tree
	enable_vertical_overscroll
	enable_vertical_scrolling_per_item
	fixme (comment: STRING_8)
	free_id
	hide
	hide_column (a_column: INTEGER_32)
	hide_header
	hide_horizontal_scroll_bar
	hide_tree_node_connectors
	hide_vertical_scroll_bar
	insert_new_column (a_index: INTEGER_32)
	insert_new_row (i: INTEGER_32)
	insert_new_row_parented (i: INTEGER_32; a_parent_row: EV_GRID_ROW)
	insert_new_rows (rows_to_insert, i: INTEGER_32)
	insert_new_rows_parented (rows_to_insert, i: INTEGER_32; a_parent_row: EV_GRID_ROW)
	lock_update
	move_column (i, j: INTEGER_32)
	move_columns (i, j, n: INTEGER_32)
	move_row (i, j: INTEGER_32)
	move_row_to_parent (i, j: INTEGER_32; a_parent_row: EV_GRID_ROW)
	move_rows (i, j, n: INTEGER_32)
	move_rows_to_parent (i, j, n: INTEGER_32; a_parent_row: EV_GRID_ROW)
	redraw
	refresh_now
	remove_background_pixmap
	remove_column (a_column: INTEGER_32)
	remove_default_key_processing_handler
	remove_help_context
	remove_item (a_column, a_row: INTEGER_32)
	remove_pebble
	remove_real_source
	remove_real_target
	remove_row (a_row: INTEGER_32)
	remove_rows (lower_index, upper_index: INTEGER_32)
	remove_selection
	remove_tooltip
	select_column (a_column: INTEGER_32)
	select_row (a_row: INTEGER_32)
	set_accept_cursor (a_cursor: [like accept_cursor] EV_POINTER_STYLE)
	set_actual_drop_target_agent (an_agent: [like actual_drop_target_agent] FUNCTION [ANY, TUPLE [INTEGER_32, INTEGER_32], EV_ABSTRACT_PICK_AND_DROPABLE])
	set_background_color (a_color: [like background_color] EV_COLOR)
	set_background_pixmap (a_pixmap: EV_PIXMAP)
	set_column_count_to (a_column_count: INTEGER_32)
	set_data (some_data: [like data] ANY)
	set_default_colors
	set_default_key_processing_handler (a_handler: [like default_key_processing_handler] PREDICATE [ANY, TUPLE [EV_KEY]])
	set_deny_cursor (a_cursor: [like deny_cursor] EV_POINTER_STYLE)
	set_drag_and_drop_mode
	set_dynamic_content_function (a_function: FUNCTION [ANY, TUPLE [INTEGER_32, INTEGER_32], EV_GRID_ITEM])
	set_first_visible_row (a_row: INTEGER_32)
	set_focus
	set_focused_selection_color (a_color: EV_COLOR)
	set_focused_selection_text_color (a_color: EV_COLOR)
	set_foreground_color (a_color: [like foreground_color] EV_COLOR)
	set_help_context (an_help_context: [like help_context] FUNCTION [ANY, TUPLE, EV_HELP_CONTEXT])
	set_item (a_column, a_row: INTEGER_32; a_item: EV_GRID_ITEM)
	set_item_accept_cursor_function (a_function: FUNCTION [ANY, TUPLE [EV_GRID_ITEM], EV_POINTER_STYLE])
	set_item_deny_cursor_function (a_function: FUNCTION [ANY, TUPLE [EV_GRID_ITEM], EV_POINTER_STYLE])
	set_item_pebble_function (a_function: FUNCTION [ANY, TUPLE [EV_GRID_ITEM], ANY])
	set_item_veto_pebble_function (a_function: FUNCTION [ANY, TUPLE [EV_GRID_ITEM, ANY], BOOLEAN])
	set_minimum_height (a_minimum_height: INTEGER_32)
	set_minimum_size (a_minimum_width, a_minimum_height: INTEGER_32)
	set_minimum_width (a_minimum_width: INTEGER_32)
	set_node_pixmaps (an_expand_node_pixmap, a_collapse_node_pixmap: EV_PIXMAP)
	set_non_focused_selection_color (a_color: EV_COLOR)
	set_non_focused_selection_text_color (a_color: EV_COLOR)
	set_pebble (a_pebble: [like pebble] ANY)
	set_pebble_function (a_function: FUNCTION [ANY, TUPLE, ANY])
	set_pebble_position (a_x, a_y: INTEGER_32)
	set_pick_and_drop_mode
	set_pointer_style (a_cursor: [like pointer_style] EV_POINTER_STYLE)
	set_real_source (dockable_source: EV_DOCKABLE_SOURCE)
	set_real_target (a_target: EV_DOCKABLE_TARGET)
	set_row_count_to (a_row_count: INTEGER_32)
	set_row_height (a_row_height: INTEGER_32)
	set_separator_color (a_color: EV_COLOR)
	set_subrow_indent (a_subrow_indent: INTEGER_32)
	set_target_menu_mode
	set_target_name (a_name: STRING_GENERAL)
	set_tooltip (a_tooltip: STRING_GENERAL)
	set_tree_node_connector_color (a_color: EV_COLOR)
	set_veto_dock_function (a_function: FUNCTION [ANY, TUPLE [EV_DOCKABLE_SOURCE], BOOLEAN])
	set_virtual_position (virtual_x, virtual_y: INTEGER_32)
	show
	show_column (a_column: INTEGER_32)
	show_header
	show_horizontal_scroll_bar
	show_tree_node_connectors
	show_vertical_scroll_bar
	to_implement (comment: STRING_8)
	unlock_update
	wipe_out