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