    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