org.vishia.gral.base

## Class GralTable<UserData>

- java.lang.Object
- - org.vishia.gral.base.GralWidget
  - - org.vishia.gral.base.GralTable<UserData>

- All Implemented Interfaces:
    GetGralWidget_ifc, GralSetValue_ifc, GralTable_ifc<UserData>, GralWidget_ifc, Removeable

      public final class GralTable<UserData>
      extends GralWidget
      implements GralTable_ifc<UserData>

  This is the Gral class for a table. Its usage is independent of a graphical implementation layer. A table consists of some text fields which are arranged in columns and lines. The lines can be associated to any user data.
  Data, text and graphic architecture of the table:
  All data which are managed in this table are contained in an Tree node `rootLine` with a unlimited size. That container references instances of `GralTable.TableLineData`. Each of that table line contains the texts which are displayed in the cells, the color etc., a key for searching and a reference to any user data. In that kind a table is a container class with a graphical touch.
  For presenting the table in a graphic implementation some text fields are arranged in a line and column structure in any panel or canvas. The number of such fields for the lines is limited, only the maximal number of viewable lines should be present (about 20 to 50), independent of the length of the table. If any part of the table will be shown, that fields will be filled with the texts from the `GralTable.TableLineData.cellTexts` of the corresponding line. If the table content will be shifted in the visible area, the text content of the fields are replaced.
  Each text field refers an instance of `GralTable.CellData` as its 'user data'. The CellData refers via `CellData#tableItem` the line.

         Graphic representation     GralTable        GralTable.TableLineData
                   |                   |<--------------<#>|
          |<*------+                   |                  |<>--userData--->User's data
         TextField                     |---rootLine-----*>|
          |<>------>CellData           |---lineSelected-->|-->cellTexts
                       |                                  |-->colors
                       |---tableItem--------------------->|

  UML presentation, see `Docu_UML_simpleNotation`.
  A `GralTable.TableLineData` refers any aggregated user data, associated with `insertLine(String, int, String[], Object)` or `GralTable.NodeTableLine.addChildLine(String, String[], Object)` etc. The user data can be gotten with `GralTable.TableLineData.getUserData()`. The user data are not part of the graphical presentation by automatism. They can be used for graphical implementation by the application, especially to provide the texts or maybe colors for the table line cells.
  Keyboard handling in a table:
  The table has its own `GralTable.GraphicImplAccess.processKeys(int)` method which is called from the graphical implementation layer in an key event handler. This method processes some keys for navigation and selection in the table. If the key is not used for that, first the action of `GralWidget.setActionChange(GralUserAction)` will be invoked with the key. If that method returns false, the key will be offer the `GralMng.userMainKeyAction` for a global key usage.
  Especially Mouse double click etc. can be handled in the change action.
  Focus handling in a table:
  - If a cell gets the focus by mouse click, whereby another cell of the table has lost the focus before, the focus state of the table is not changed. Only the `specifyActionOnLineSelected(GralUserAction)` is called.
  - If a cell gets the focus by mouse click, whereby the table has not the focus before, the `GralWidget.setActionFocused(GralUserAction)` is called from the focus action of the presentation graphic layer.
  - If `GralWidget.setFocus()` is called from outside, the selected cell is marked with `GraphicImplAccess.CellData#bSetFocus`. The following repaint sets the focus for that cell.
  Adding an context menu:
  The `addContextMenuEntryGthread(int, String, String, GralUserAction)` can be invoked for the table only in the graphic thread. Use any `GralGraphicTimeOrder` to do that, use a callback with this time order on the creation of the table.

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `GralTable.CellData` Data for each Text widget of the graphical implementation layer.
    `class` | `GralTable.GraphicImplAccess` This is the super class for all implementers.
    `static class` | `GralTable.LinePresentation` Only used on invocation of `GralTable.GraphicImplAccess.drawCellContent(int, org.vishia.gral.base.GralTable.CellData[], org.vishia.gral.base.GralTable<?>.TableLineData, org.vishia.gral.base.GralTable.LinePresentation)`.
    `class` | `GralTable.NodeTableLine` This class is the super class of `GralTable.TableLineData` which presents a line as a node in a tree.
    `class` | `GralTable.TableLineData` An instance of this class presents a line in a table or a node or leaf in a tree.

    - ### Nested classes/interfaces inherited from class org.vishia.gral.base.GralWidget

      `GralWidget.ActionChangeSelect, GralWidget.ConfigData, GralWidget.DynamicData, GralWidget.ImplAccess`

    - ### Nested classes/interfaces inherited from interface org.vishia.gral.ifc.GralWidget_ifc

      `GralWidget_ifc.ActionChange, GralWidget_ifc.ActionChangeWhen`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected MarkMask_ifc` | `actionMarkOnLine` This action will be called if any line is marked.
    `(package private) GralUserAction` | `actionOnLineSelected` This action will be called any time when the selection of the current line is changed.
    `(package private) GralUserAction` | `actionOnRefreshChildren` This action will be called any time when children of a tree node line should be refreshed.
    `(package private) boolean` | `bChangedLinesForCell`
    `protected boolean[]` | `bColumnEditable`
    `protected boolean` | `bPrepareVisibleArea` If true then the graphic implementation fields for cells should be filled newly with the text.
    `protected GralColor` | `colorBackMarked` The color of that lines which are marked.
    `protected GralColor` | `colorBackSelect` The color of the current line.
    `protected GralColor` | `colorBackSelectMarked` The color of the current, the selected line if it is marked.
    `protected GralColor` | `colorBackSelectNew`
    `protected GralColor` | `colorBackSelectNewMarked`
    `protected GralColor` | `colorBackSelectSomeMarked` The color of the current selected line if some children of it are marked.
    `protected GralColor` | `colorBackSomeMarked` The color of that lines which's some children are marked.
    `protected GralColor` | `colorBackVscrollbar` Background of VscrollBar.
    `protected GralColor` | `colorSelectChars`
    `protected GralColor` | `colorSelectCharsBack`
    `protected GralColor[]` | `colorSliderVscrollbar` 20 nuances of color for the slider of the vertical scrollBar.
    `protected GralColor` | `colorTextMarked`
    `protected GralColor` | `colorTextSelect`
    `protected int` | `colSelectedixCellC` The currently selected cell.
    `protected int[]` | `columnWidthsGral` Width of each column in GralUnits.
    `(package private) GralTable.GraphicImplAccess` | `gi`
    `protected GralGraphicTimeOrder` | `keyActionDone` This callback is need because the paint of a table needs more time if a slow processor is used and the key repeat rate is higher than the calculation time.
    `protected int` | `keyCloseChild`
    `protected boolean` | `keyDone` If set, then a next key will be processed.
    `protected int` | `keyMarkDn`
    `protected int` | `keyMarkUp`
    `protected int` | `keyOpenChild`
    `private int` | `keyRepetition` Number of key repetitions if a key was not used because the redraw was pending yet.
    `protected java.lang.String` | `keySeparator`
    `private int` | `lastKey` The last key which was pressed
    `protected GralTable.TableLineData` | `lineSelected` The current line.
    `protected int` | `lineSelectedixCell` The currently selected cell.
    `protected GralTable.TableLineData` | `lineSelectedNew` The line which is selected by mouse pressing, for right mouse menu.
    `protected int` | `lineSelectedNewixCell`
    `protected GralTable.TableLineData[]` | `linesForCell` Array of lines which are currently associated to the cells of the implementation layer.
    `protected GralMenu[]` | `menuColumns`
    `private int` | `nLineFirst` Number of lines and number of the current line.
    `(package private) GralTable.NodeTableLine` | `rootLine` The root for all lines of the table.
    `protected java.lang.StringBuilder` | `searchChars`
    `protected static java.lang.String` | `sVersion` Version, history and license.
    `protected long` | `timeLastRedraw` Check the last time of redrawing.
    `protected int` | `XXXdLineForCells` Difference of changing ixLine for cells. 0: Assignment not changed.
    `protected int` | `zColumn` Number of lines and columns of data.
    `protected int` | `zLine` Number of lines and columns of data.
    `private int` | `zLineCurr` Number of lines and number of the current line.
    `protected int` | `zLineVisible` Current number of visible lines in the view.
    `protected int` | `zLineVisibleMax`

    - ### Fields inherited from class org.vishia.gral.base.GralWidget

      `_wdgImpl, bEditable, bHasFocus, bShouldInitialize, buildMng, bVisibleState, cfg, contextMenu, dateUser, dyda, htmlHelp, itsMng, lastTimeSetVisible, name, repaintDelay, repaintDelayMax, sCmd, sFormat, sToolTip, whatIs`

    - ### Fields inherited from interface org.vishia.gral.ifc.GralTable_ifc

      `kAllLines, kEmptyArea, version`

    - ### Fields inherited from interface org.vishia.gral.ifc.GralSetValue_ifc

      `version`

    - ### Fields inherited from interface org.vishia.gral.base.GetGralWidget_ifc

      `version`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `GralTable(java.lang.String posName, int[] columnWidths)` Constructs a table which should be positioned on `GralWidget.setToPanel(GralMngBuild_ifc)` see `GralTable(String, int, int[])`, zLineMax is 50.
    `GralTable(java.lang.String posName, int zLineMax, int[] columnWidths)` Constructs a table which should be positioned on `GralWidget.setToPanel(GralMngBuild_ifc)`
    `GralTable(java.lang.String pos, java.lang.String name, int[] columnWidths)` Constructs a table with position

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `private void` | `actionOnLineSelected(int key, GralTableLine_ifc<?> line)` It is called whenever another line is selected, if the focus is gotten by mouse click or a navigation key is pressed.
    `protected void` | `actionOnRefreshChildren(GralTableLine_ifc<?> line)` It is called whenever another line is selected, if the focus is gotten by mouse click or a navigation key is pressed.
    `void` | `addContextMenuEntryGthread(int col, java.lang.String menuname, java.lang.String sMenuPath, GralUserAction action)` Adds a context menu entry for the given column.
    `GralTable.TableLineData` | `addLine(java.lang.String lineKey, java.lang.String[] lineTexts, UserData userData)` Inserts a line in the table with given content.
    `protected void` | `checkAndUpdateText(java.lang.String sText, GralTable.CellData celldata)` Invoked from focus lost of any table cell implementation, checks whether the line is changed.
    `void` | `clearTable()`
    `void` | `deleteLine(GralTableLine_ifc<UserData> line)` Deletes a line in the table.
    `private void` | `fillVisibleArea()`
    `private void` | `fillVisibleAreaBehind(GralTable.TableLineData lineStart, int ixStart)`
    `TreeNode_ifc<?,UserData>` | `getAllLines()` Returns all lines.
    `java.lang.String` | `getCellTextFocus()` Gets the text of any cell which is in focus.
    `GralMenu` | `getContextMenuColumn(int col)` Returns the same context menu for all cells of the designated column.
    `GralMenu` | `getContextMenuColumnCells(int col, java.lang.String name, java.lang.String sMenuPath, GralUserAction action)` Adds a context menu entries to all cells of the designated column.
    `GralTable.TableLineData` | `getCurrentLine()` Returns the current selected line.
    `GralTableLine_ifc<UserData>` | `getFirstMarkedLine(int mask)` Returns the first line from top of the table which is marked or null if no line is marked.
    `int` | `getIxLine(GralTableLine_ifc<UserData> line)` Gets the index in the visual presentation of the given line.
    `GralTableLine_ifc<UserData>` | `getLine(java.lang.String key)` Get the line which is designated with the requested key.
    `GralTable.TableLineData` | `getLineMousePressed()` Returns the temporary selected line while pressing the mouse button.
    `java.util.List<UserData>` | `getListContent()` Returns all content of lines.
    `java.util.List<GralTableLine_ifc<UserData>>` | `getMarkedLines(int mask)` Returns all marked lines.
    `GralTable.TableLineData` | `insertLine(java.lang.String lineKey, int row, java.lang.String[] lineTexts, UserData userData)` Inserts a line in the table with given content.
    `IterableIterator<GralTable.TableLineData>` | `iterLines()` Returns in iterable object for the lines which can used in a for-element expression or in a `Iterator` usage.
    `protected void` | `mouseDouble(int key, GralTable.CellData cell)` Invoked in the graphic thread from mouse listener in `GraphicImplAccess#mouseDoubleGral(int, CellData)`
    `protected void` | `mouseDown(int key, GralTable.CellData cell)` Invoked in the graphic thread from mouse listener in `GraphicImplAccess#mouseDownGral(int, CellData)`
    `protected void` | `mouseUp(int key, GralTable.CellData cell)` Invoked in the graphic thread from mouse listener in `GraphicImplAccess#mouseUpGral(int, CellData)`
    `(package private) GralTable.TableLineData` | `nextLine(GralTable.TableLineData lineP)`
    `int` | `nrofLinesVisibleMax()`
    `(package private) GralTable.TableLineData` | `prevLine(GralTable.TableLineData lineP)`
    `protected boolean` | `processKeys(int keyCode)` Handle all standard keys of table.
    `protected boolean` | `searchContent(boolean bUp)` Increments or decrements ixLineNew in [up] or [dn] situation until the `searchChars` are found or one time if searchChars are not given.
    `void` | `setColorBackSelectedLine(GralColor color)` Sets the color of the currently selected line.
    `(package private) void` | `setColors()`
    `void` | `setColumnEditable(int column, boolean val)` Sets the specified column to edit-able or not.
    `void` | `setColumnWidth(int width, int[] columnWidths)`
    `void` | `setCurrentLine(GralTableLine_ifc<UserData> line, int ixline, int ixcolumn)` Sets the cell which is the current one in the given line.
    `boolean` | `setCurrentLine(java.lang.String key)` Sets the line which is the current one.
    `void` | `setFocus(int delay, int latest)` Sets the focus of the table.
    `protected int` | `shiftVisibleArea(int dLine)` Shifts the content in `linesForCell` to show the appropriate part of data (e.g. lines of `rootLine`)in the table.
    `int` | `size()` Returns the number of active lines of the table.
    `void` | `specifyActionOnLineMarked(MarkMask_ifc action)`
    `void` | `specifyActionOnLineSelected(GralUserAction action)` Sets an action which is called any time when another line is selected.
    `void` | `specifyActionOnRefreshChildren(GralUserAction action)` Sets an action which is called any time when another line is selected.
    `void` | `specifyKeysMarkUpDn(int up, int dn)` Specifies the keys to mark lines in the table.
    `GralTable.TableLineData` | `XXXaddLine(java.lang.String key, java.lang.String[] cellTexts, UserData userData)`
    `GralTable.TableLineData` | `XXXinsertLine(java.lang.String key, int row, java.lang.String[] cellTexts, UserData userData)`

    - ### Methods inherited from class org.vishia.gral.base.GralWidget

      `chgPos, clearShowParam, createImplWidget_Gthread, getActionChange, getActionChangeStrict, getActionDrag, getActionDrop, getActionFocused, getActionShow, getBackColor, getCfgElement, getCmd, getCmd, getContentIdent, getContentInfo, getContextMenu, getData, getDataIx, getDataPath, getDataPath, getFloatValue, getFormat, getGralWidget, getHtmlHelp, getImpl, getItsPanel, getLongValue, getName, getShowMethod, getShowParam, getsToolTip, getText, getValue, getVariable, getVariableFromContentInfo, gralMng, isChanged, isEditable, isGraphicDisposed, isInFocus, isNotEditableOrShouldInitialize, isVisible, pos, refreshFromVariable, refreshFromVariable, registerWidget, remove, repaint, repaint, requestNewValueForVariable, setActionChange, setActionFocused, setActionMouse, setActionShow, setBackColor, setBackgroundColor, setBoundsPixel, setCfgElement, setCmd, setContentIdent, setContentInfo, setData, setDataIx, setDataPath, setDragEnable, setDropEnable, setEditable, setFocus, setForegroundColor, setFormat, setHtmlHelp, setLineColor, setLongValue, setMinMax, setPanelMng, setPrimaryWidgetOfPanel, setText, setTextColor, setToolTip, setToPanel, setValue, setValue, setValue, setValue, setVisible, setVisibleState, setVisibleStateWidget, specifyActionChange, specifyContextMenu, stop, toString, XXXgetPixelPositionSize, XXXgetWidgetImplementation, XXXremoveWidgetImplementation, XXXrepaintGthread, XXXsetFocusGThread, XXXsetVisibleGThread`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface org.vishia.gral.ifc.GralTable_ifc

      `getBackColor, setBackColor`

    - ### Methods inherited from interface org.vishia.gral.ifc.GralWidget_ifc

      `createImplWidget_Gthread, getActionChange, getCmd, getContentIdent, getContentInfo, getData, getDataPath, getName, gralMng, isChanged, isEditable, isGraphicDisposed, isInFocus, isNotEditableOrShouldInitialize, isVisible, refreshFromVariable, refreshFromVariable, repaint, repaint, setBackgroundColor, setBoundsPixel, setCmd, setContentIdent, setData, setDataPath, setEditable, setFocus, setForegroundColor, setHtmlHelp, setLineColor, setText, setTextColor, setToPanel, setVisible`

    - ### Methods inherited from interface org.vishia.util.Removeable

      `remove`

- - ### Field Detail

    - #### sVersion

          protected static final java.lang.String sVersion

      Version, history and license.
      - 2018-10-28 Hartmut chg: Now uses argument zLineMax from `GralTable(String, int, int[])` instead constant 50 for number of showed lines.
      - 2018-01-07 Hartmut new: `getCellTextFocus()`
      - 2016-09-17 Hartmut new: in `mouseDouble(int, CellData)` the `getActionChangeStrict(ActionChangeWhen.onMouse1Double, true)` is checked. Therewith the new concept of `GralWidget.specifyActionChange(String, GralUserAction, String[], org.vishia.gral.ifc.GralWidget_ifc.ActionChangeWhen...)` for specific actions is used here now. Firstly only for the mouse double click action. TODO: for all specific actions.
      - 2016-09-01 Hartmut new: `getIxLine(GralTableLine_ifc)` to determine the current position of a given table line.
      - 2016-08-28 Hartmut chg: `GralTable.GraphicImplAccess.setBoundsCells(int, int)` now gets the zLineVisible. The `SwtTable.setBoundsCells(int, int)` sets the rest of texts invisible. Therewith the phenomena of ghost lines on resizing are removed.
      - 2016-08-28 Hartmut chg: Bugfix: In `GralTable.GraphicImplAccess.resizeTable(GralRectangle)`: The `GralWidget.pos()` should not be used because the Composite is resized with it already. Instead the number of lines is correctly calculated now and `GralTable.GraphicImplAccess.setBoundsCells(int, int)` is invoked with that `zLineVisible`.
      - 2015-11-19 Hartmut chg: Some changes for future: The cells should be managed in the GralTable, not in SwtTable. Adaption for AwtTable
      - 2015-10-29 Hartmut chg: `GralTable.TableLineData.bChangedSet`, the content will be written in `SwtTable` or another graphic implementation only if the text is changed. Therewith editing a table is possible while the other cells are updated frequently. That can be used for tables which shows a current state, and a column is editable. See `InspcViewTargetComm`.
      - 2015-08-28 Hartmut chg: `processKeys(int)`: Use tab and sh-tab to switch between the columns. This keys are used as 'traverse key' normally, but they are ignored for that now by a proper TraverseListener in `SwtTable`. The standard traverse listener which is active for traversing between the text fields of the table does not set the correct `colSelectedixCellC` which is necessary for accept the column.
      - 2015-08-28 Hartmut new: Search in columns:
        - Use the keys without shiftDigit-designation if it is a text key. It is not possible to use elsewhere.
        - `searchContent(boolean)`: If the search string starts with '*' it searches 'contains(...)'.
      - 2015-07-12 Hartmut new: `GralTable.TableLineData.setBackColor(org.vishia.gral.ifc.GralColor, int)` with colorSelect etc. for content-depending table presentation.
      - 2015-06-21 Hartmut chg: Implementation of `TableLineData#setBackColor(GralColor, int`} now regards the ix-argument as cell index, like defined in comment.
      - 2015-05-31 Hartmut chg: `GraphicImplAccess#processKeys(int`} updates the cell text in the line firstly if it is an editing cell. It helps to get the correct text in the graphic thread.
      - 2014-12-26 Hartmut chg: `colorBackSelectSomeMarked` etc.
      - 2013-12-23 Hartmut chg: Rename `setColorBackSelectedLine(GralColor)` instead setColorCurrLine(): It is not the current line which is changed but the color setting for all current (= selected) lines.
      - 2013-12-23 Hartmut chg: `checkAndUpdateText(String, CellData)` supports update text on edit cells.
      - 2013-12-18 Hartmut chg: `GralTable.CellData` is defined now public and as part of GralTable. There were a problem using the Java7-Compiler with difficult Generic parameter mismatches. The CellData is a simple data class without generic, but the compiler has interpreted a generic parameter. May the compiler wrong? The structure of a program should be simple! The only one disadvantage is, `GralTable.CellData` has to be public, not protected, because it is not seen from the implementation class of `GralTable.GraphicImplAccess`. Another problem was `GraphicImplAccess#mouseDownGral()` etc. The compiler has a problem it was named 'mouseDown' and 'super.mouseDown(ev)' was called from the derivated class. Keep it simple. It does not need the same name.
      - 2013-12-06 Hartmut new: `setColumnEditable(int, boolean)`, supports editing in cells.
      - 2013-11-24 Hartmut chg: `GralTable.GraphicImplAccess#focusGained()` etc. refactored.
      - 2013-11-23 Hartmut chg: use `KeyCode.userSelect` etc. for calling `actionOnLineSelected(int, GralTableLine_ifc)`
      - 2013-11-16 Hartmut chg: setCurrentCell(int, int) removed because the line number without respect to a line is not able to handle. Only a line is given. New method `setCurrentLine(GralTableLine_ifc, int, int)` can set the given line to any location in the visible area of table.
      - 2013-11-15 Hartmut new: `GralTable.TableLineData` and `GralTable.GraphicImplAccess` are non-static yet because the generic type should be the same without additional effort. This is the reason. Nevertheless the non-static property was given already, but deployed by the outer aggregation of the static one.
      - 2013-10-03 Hartmut new: `GralTable.TableLineData` now extends `TreeNodeBase`. It is a tree.
      - 2013-10-03 Hartmut new: `GralTable.GraphicImplAccess.cells`, the `GraphicImplAccess.CellData` are able to access elsewhere only in the implementation layer via the text widget.
      - 2013-11-02 Hartmut chg: `GralTable.TableLineData` is static now with outer reference, more transparent
      - 2013-11-02 Hartmut chg: `GralTable.GraphicImplAccess.resizeTable(GralRectangle)` moved from SWT implementation, preparing tree view. `GralTable.TableLineData.treeDepth()`, `GralTable.TableLineData#childLines` for tree view.
      - 2013-11-02 Hartmut chg: `GralTable.TableLineData` is static now with outer reference, more transparent
      - 2013-10-06 Hartmut chg: call `actionOnLineSelected(int, GralTableLine_ifc)` only if the line is changed, not on focus without changed line.
      - 2013-09-15 Hartmut new: Implementation of `GralWidget.setBackColor(GralColor, int)` with special comments for usage of the int parameter. See `GralTable_ifc.setBackColor(GralColor, int)`, Adequate `GralWidget.getBackColor(int)`.
      - 2013-09-14 Hartmut chg: `GralTable.GraphicImplAccess` implements now `GralWidgImpl_ifc` without any other changes (was proper) and sets `GralWidget._wdgImpl`. Therefore all routines which works from the GralWidget calls the methods of the implement of the GralTable immediately without special overridden methods in this class. It is the concept.
      - 2013-09-14 Hartmut chg: uses the `GralWidget.DynamicData.backColor` etc.
      - 2013-08-11 Hartmut chg: `#getMarkedLines()` now checkes the `TableLineData#userData` whether that is instanceof `MarkMask_ifc`. If true then uses its selection state instead the selection state of the `GralTable.TableLineData`.
      - 2013-06-29 Hartmut chg: refactoring. Now a GralTable can be created before the graphic is build. It is the new schema of GralWidget. The inner class `GralTable.GraphicImplAccess` is provided as super class for the graphic implementation class, for example `SwtTable`.
      - 2013-06-12 Hartmut chg: On right mouse pressing the current line will be selected, because the context menu should have an association to that line.
      - 2013-06-12 Hartmut chg: A marked line is now designated with a background color. A selected marked line has another background than a selected non marked line (to see it).
      - 2013-06-11 Hartmut new: Now the `GralTable`, the `GralTable.TableLineData` and this interface are marked with the generic type UserData.
      - 2013-05-22 Hartmut new: `TableLineData#lineInGraphic` not used yet, but for further usage. Maybe for refresh data only if they are in the visible range. 2013-10-03 removed, too many effort on tree view. To detect visible lines iterate over `GralTable.GraphicImplAccess.cells`
      - 2013-05-11 Hartmut chg: `deleteLine(GralTableLine_ifc)` was not ready, now tested
      - 2013-05-11 Hartmut chg: `GralTable.TableLineData` instead TableItemWidget.
      - 2013-04-28 Hartmut new: `specifyKeysMarkUpDn(int, int)`
      - 2013-04-28 Hartmut new: `specifyActionOnLineMarked(MarkMask_ifc)`
      - 2013-04-28 Hartmut renamed: `actionOnLineSelected(int, GralTableLine_ifc)`
      - 2013-04-21 Hartmut chg: `processKeys(int)`: input of a text key starts searching for a line with this key immediately, better handling for usage.
      - 2012-08-22 Hartmut new `#setCurrentLine(int)` with int, it isn't new because it was able to set with `#setCurrentCell(int, int)` with -1 as second parameter.
      - 2012-07-15 Hartmut new: search functionality: The implementation should/may have a text field which shows the search string. While up and down keys the that lines are selected which text in the `#ixColumn` starts with the search string.
      - 2012-03-09 Hartmut bugfix: The `#idxLine` was not cleared if the table was cleared.
      - 2012-02-19 Hartmut new: mouseWheel and double click
      - 2012-01-30 Hartmut new: `#setColorCurrLine(GralColor)`
      - 2012-01-15 Hartmut new: `setCurrentLine(String)`, `insertLine(String, int, String[], Object)`: the key is supported now.
      - 2012-01-06 Hartmut new: concept of a table which is independent of the table implementation of the table implementations in the graphic system layer or in operation system: The capability of a SWT-table is not sufficient, for example the color of the selection bar is not able to change. Other reason: Implementation of table in SWT, AWT, Swing is different. It seems better to have one table concept with independent features, which based on simple widgets. is not
      - 2011-12-30 Hartmut chg `#procStandardKeys(int, GralTableLine_ifc, int)` returns true if standard keys are used.
      - 2011-11-27 Hartmut new `actionOnLineSelected(int, GralTableLine_ifc)`: The user action is called anytime if a line is selected by user operation. It can be show any associated content anywhere additionally. It is used for example in "The.file.Commander" to show date, time and maybe content while the user selects any files. The graphical implementation should be call `actionOnLineSelected(int, GralTableLine_ifc)` in its Selection listener.
      - 2011-11-20 Hartmut new The capability of selection of lines is moved from the `GralSelectList` to this class. It means any table has the capability of selection of multiple lines. This capability is supported with a extension of the `GralTableLine_ifc` with `MarkMask_ifc`. The selection of a line is notificated in the users data which are associated with the table line, not in the graphic representation of the table. This is differenced to SWT Table implementation. The capability of selection in an SWT table isn't used. The selection is done by default with shift-key up/down or with mouse selection ctrl-click, shift-click like usual. The selection is not missed if the up/down keys are pressed furthermore. More as that, more as one ranges of lines can be selected. That is a better capability than in SWT.
      Copyright/Copyleft: For this source the LGPL Lesser General Public License, published by the Free Software Foundation is valid. It means:
      1. You can use this source without any restriction for any desired purpose.
      2. You can redistribute copies of this source to everybody.
      3. Every user of this source, also the user of redistribute copies with or without payment, must accept this license for further using.
      4. But the LPGL is not appropriate for a whole software product, if this source is only a part of them. It means, the user must publish this part of source, but don't need to publish the whole source of the own product.
      5. You can study and modify (improve) this source for own using or for redistribution, but you have to license the modified sources likewise under this LGPL Lesser General Public License. You mustn't delete this Copyright/Copyleft inscription in this source file.
      If you are intent to use this sources without publishing its usage, you can get a second license subscribing a special contract with the author.
      See Also:
        Constant Field Values

    - #### keyMarkUp

          protected int keyMarkUp

    - #### keyMarkDn

          protected int keyMarkDn

    - #### keyOpenChild

          protected int keyOpenChild

    - #### keyCloseChild

          protected int keyCloseChild

    - #### keySeparator

          protected java.lang.String keySeparator

    - #### actionOnLineSelected

          GralUserAction actionOnLineSelected

      This action will be called any time when the selection of the current line is changed. The `GralUserAction.exec(int, GralWidget_ifc, Object...)` will be called with the line as Object.

    - #### actionOnRefreshChildren

          GralUserAction actionOnRefreshChildren

      This action will be called any time when children of a tree node line should be refreshed. The `GralUserAction.exec(int, GralWidget_ifc, Object...)` will be called with the line as Object.

    - #### columnWidthsGral

          protected int[] columnWidthsGral

      Width of each column in GralUnits.

    - #### bColumnEditable

          protected boolean[] bColumnEditable

    - #### menuColumns

          protected GralMenu[] menuColumns

    - #### gi

          GralTable.GraphicImplAccess gi

    - #### lineSelectedixCell

          protected int lineSelectedixCell

      The currently selected cell.

    - #### colSelectedixCellC

          protected int colSelectedixCellC

      The currently selected cell.

    - #### lineSelectedNewixCell

          protected int lineSelectedNewixCell

    - #### linesForCell

          protected GralTable.TableLineData[] linesForCell

      Array of lines which are currently associated to the cells of the implementation layer. It means they are the showing lines. Note that the TableLineData referred with the `rootLine` are all of the lines of the table. They are not associated to any graphic widget any time. Whether they are associated to a graphic widget or not is able to evaluate with this array. The cellLines[0] is the TableLineData of the first visible line in any case etc.

    - #### bChangedLinesForCell

          boolean bChangedLinesForCell

    - #### lineSelected

          protected GralTable.TableLineData lineSelected

      The current line.

    - #### lineSelectedNew

          protected GralTable.TableLineData lineSelectedNew

      The line which is selected by mouse pressing, for right mouse menu.

    - #### zLine

          protected int zLine

      Number of lines and columns of data.

    - #### zColumn

          protected int zColumn

      Number of lines and columns of data.

    - #### zLineVisible

          protected int zLineVisible

      Current number of visible lines in the view.

    - #### zLineVisibleMax

          protected int zLineVisibleMax

    - #### zLineCurr

          private int zLineCurr

      Number of lines and number of the current line. It is -1 if this numbers should be evaluated from `rootLine`

    - #### nLineFirst

          private int nLineFirst

      Number of lines and number of the current line. It is -1 if this numbers should be evaluated from `rootLine`

    - #### searchChars

          protected final java.lang.StringBuilder searchChars

    - #### rootLine

          GralTable.NodeTableLine rootLine

      The root for all lines of the table. It may be a tree. The lines are the nodes of the tree which are shown.

    - #### bPrepareVisibleArea

          protected boolean bPrepareVisibleArea

      If true then the graphic implementation fields for cells should be filled newly with the text.

    - #### XXXdLineForCells

          protected int XXXdLineForCells

      Difference of changing ixLine for cells. 0: Assignment not changed. It is used in `#redrawTableWithFocusedCell(CellData)`

    - #### timeLastRedraw

          protected long timeLastRedraw

      Check the last time of redrawing.

    - #### keyDone

          protected boolean keyDone

      If set, then a next key will be processed. It is set to false if a key event is executed and it is set to true in `keyActionDone`.

    - #### lastKey

          private int lastKey

      The last key which was pressed

    - #### keyRepetition

          private int keyRepetition

      Number of key repetitions if a key was not used because the redraw was pending yet.

    - #### colorBackSelect

          protected GralColor colorBackSelect

      The color of the current line. It is the selected line

    - #### colorBackMarked

          protected GralColor colorBackMarked

      The color of that lines which are marked.

    - #### colorBackSelectMarked

          protected GralColor colorBackSelectMarked

      The color of the current, the selected line if it is marked.

    - #### colorBackSomeMarked

          protected GralColor colorBackSomeMarked

      The color of that lines which's some children are marked.

    - #### colorBackSelectSomeMarked

          protected GralColor colorBackSelectSomeMarked

      The color of the current selected line if some children of it are marked.

    - #### colorBackSelectNew

          protected GralColor colorBackSelectNew

    - #### colorBackSelectNewMarked

          protected GralColor colorBackSelectNewMarked

    - #### colorTextSelect

          protected GralColor colorTextSelect

    - #### colorTextMarked

          protected GralColor colorTextMarked

    - #### colorSelectCharsBack

          protected GralColor colorSelectCharsBack

    - #### colorSelectChars

          protected GralColor colorSelectChars

    - #### colorBackVscrollbar

          protected GralColor colorBackVscrollbar

      Background of VscrollBar.

    - #### colorSliderVscrollbar

          protected final GralColor[] colorSliderVscrollbar

      20 nuances of color for the slider of the vertical scrollBar. The nuances depends on the pixel size.

    - #### actionMarkOnLine

          protected MarkMask_ifc actionMarkOnLine

      This action will be called if any line is marked. It may be null, see

    - #### keyActionDone

          protected final GralGraphicTimeOrder keyActionDone

      This callback is need because the paint of a table needs more time if a slow processor is used and the key repeat rate is higher than the calculation time. After finishing all paint requests in the graphic thread this action was called. It sets `keyDone` = true, then the next key is processed immediately. Elsewhere, if the graphic thread is busy in the graphic os dispatching and a new key event is received there, the key action won't be executed.
      It helps for a run-after effect if the key are released already but some key events are stored. If a navigation key is released, the table navigation should be stopped immediately.

  - ### Constructor Detail

    - #### GralTable

          public GralTable(java.lang.String posName,
                           int[] columnWidths)

      Constructs a table which should be positioned on `GralWidget.setToPanel(GralMngBuild_ifc)` see `GralTable(String, int, int[])`, zLineMax is 50.

    - #### GralTable

          public GralTable(java.lang.String posName,
                           int zLineMax,
                           int[] columnWidths)

      Constructs a table which should be positioned on `GralWidget.setToPanel(GralMngBuild_ifc)`
      Parameters:
        `pos` - String given position in GralPos units.
        `zLineMax` - maximal number of lines managed for content. It should be related to the size of viewing. 10..50 is proper.
        `name` - to register for symbolic access
        `columnWidths` - positive value from left: width, negative value from right: width. The last column with a positive width is used for sizeable.

    - #### GralTable

          public GralTable(java.lang.String pos,
                           java.lang.String name,
                           int[] columnWidths)

      Constructs a table with position
      Parameters:
        `pos` - String given position in GralPos units.
        `name` - to registrate
        `columnWidths` - positive value from left: width, negative value from right: width. The last column with a positive width is used for sizeable.

  - ### Method Detail

    - #### nrofLinesVisibleMax

          public int nrofLinesVisibleMax()

    - #### specifyActionOnLineSelected

          public void specifyActionOnLineSelected(GralUserAction action)

      Sets an action which is called any time when another line is selected. This action will be called any time when the selection of the current line is changed. The `GralUserAction.userActionGui(int, GralWidget, Object...)` will be called with the line as Object and the following keys:
      - `KeyCode.removed` if the table was cleard.
      - `KeyCode.defaultSelect` if the table was filled and firstly the `lineSelected` is set.
      - `KeyCode.userSelect` if the user acts with keyboard or mouse
      Parameters:
        `actionOnLineSelected` - The action, null to switch off this functionality.

    - #### specifyActionOnLineMarked

          public void specifyActionOnLineMarked(MarkMask_ifc action)

    - #### specifyActionOnRefreshChildren

          public void specifyActionOnRefreshChildren(GralUserAction action)

      Sets an action which is called any time when another line is selected. This action will be called any time when the selection of the current line is changed. The `GralUserAction.userActionGui(int, GralWidget, Object...)` will be called with the line as Object.
      Parameters:
        `actionOnLineSelected` - The action, null to switch off this functionality.

    - #### specifyKeysMarkUpDn

          public void specifyKeysMarkUpDn(int up,
                                          int dn)

      Specifies the keys to mark lines in the table. Without invocation of this method the keys `KeyCode.shift` + `KeyCode.up` respectively shift+dn are specified.
      Parameters:
        `up` - Any code defined in `KeyCode` which marks a line and selects the next line after them.
        `dn` - Any code defined in `KeyCode` which marks a line and selects the previous line after them.

    - #### addContextMenuEntryGthread

          public void addContextMenuEntryGthread(int col,
                                                 java.lang.String menuname,
                                                 java.lang.String sMenuPath,
                                                 GralUserAction action)

      Adds a context menu entry for the given column. It is an abbreviation for `getContextMenuColumn(int)` and `GralMenu.addMenuItem(String, String, GralUserAction)`. The context menu is valid for the column of the whole table independent of the line. In the `GralUserAction.exec(int, GralWidget_ifc, Object...)` method (param action) the given widget is the whole table. To get the line where the mouse was pressed:
      - `getLineMousePressed()` returns the line where the mouse was pressed to open the context menu
      - `getCurrentLine()` returns the line which was selected before. It is possible especially to work with both lines. The mouse button for the context menu does not change the current line of the table.
      Parameters:
        `col` - The column, see `getContextMenuColumn(int)`
        `identArgJbat` - The name of the entry, see `GralMenu.addMenuItem(String, String, GralUserAction)`
        `sMenuPath` - same like `GralMenu.addMenuItem(String, String, GralUserAction)`
        `action` - the action invoked on menu entered.

    - #### getContextMenuColumn

          public GralMenu getContextMenuColumn(int col)

      Returns the same context menu for all cells of the designated column. Each cells of the column gets the same context menu. It means the action has not any knowledge about the cell which has used to start the context menu. Only the whole table is associated. The advantage of this in comparison to `#getContextMenuColumnCells(int)` is: Some resources are saved, because there is only one menu item instance in the implementation layer of the graphic for all cells.
      See `#getContextMenuColumnCells(int)`. Note that the `GralWidget_ifc`-parameter of the `GralUserAction.exec(int, GralWidget_ifc, Object...)` methods of all added menu entries are given with the whole table, instance of this `GralTable`.
      Parameters:
        `col` - The column of the table, count from 0,1,...
      Returns:
        The menu to add `GralMenu.addMenuItem(String, String, GralUserAction)`.

    - #### getContextMenuColumnCells

          public GralMenu getContextMenuColumnCells(int col,
                                                    java.lang.String name,
                                                    java.lang.String sMenuPath,
                                                    GralUserAction action)

      Adds a context menu entries to all cells of the designated column. This method can't be used if either `getContextMenuColumn(int)` or `addContextMenuEntryGthread(int, String, String, GralUserAction)` are called before. That is because either only one context menu can be added to all cells of a column (saves resources) or internal an extra context menu with the same appearance can be addes to all cells of the column. Using this method creates a context menu and its entry for all cells of the column with an extra menu instance. The reason of the extra instance is: The menu instance associates the cell, and the cell associates the table line via `GralTableLine_ifc`. Because that the `GralWidget_ifc`-parameter of the `GralUserAction.exec(int, GralWidget_ifc, Object...)` of the action parameter refers the cell. Use the following template for the action:

      Parameters:
        `col` - The column of the table, count from 0,1,...
      Returns:
        The menu to add `GralMenu.addMenuItem(String, String, GralUserAction)`.

    - #### setColumnWidth

          public void setColumnWidth(int width,
                                     int[] columnWidths)

    - #### setColumnEditable

          public void setColumnEditable(int column,
                                        boolean val)

      Sets the specified column to edit-able or not. This routine can be invoked before the graphic implementation is created (before `GralWidget.setToPanel(GralMngBuild_ifc)` or after them in running mode.
      Parameters:
        `column` - the number, starting by 0.
        `val` - true then edit-able, false then read only.
      Throws:
        `java.lang.IndexOutOfBoundsException` - on faulty column.

    - #### setCurrentLine

          public boolean setCurrentLine(java.lang.String key)

      Description copied from interface: `GralTable_ifc`
      Sets the line which is the current one. The current row is unchanged.
      Specified by:
        `setCurrentLine` in interface `GralTable_ifc<UserData>`
      Parameters:
        `key` - The key of the line, given by `GralTable_ifc.insertLine(String, int, String[], Object)`.
      Returns:
        true if found.

    - #### setColors

          void setColors()

    - #### setFocus

          public void setFocus(int delay,
                               int latest)

      Sets the focus of the table. It sets an information that the selected cell should focused while drawing (`GraphicImplAccess.CellData#bSetFocus`). Than it invokes the overridden super.`GralWidget.setFocus(int, int)`. That method asserts the visibility of the table and calls `GralWidgImpl_ifc.setFocusGThread()` That method is implemented in the implementation widget layer and causes a redraw which focused the correct cell.
      Specified by:
        `setFocus` in interface `GralWidget_ifc`
      Overrides:
        `setFocus` in class `GralWidget`
      Parameters:
        `delay` - Delay in ms for invoking the focus request
      See Also:
        `GralWidget.setFocus(int, int)`

    - #### setCurrentLine

          public void setCurrentLine(GralTableLine_ifc<UserData> line,
                                     int ixline,
                                     int ixcolumn)

      Description copied from interface: `GralTable_ifc`
      Sets the cell which is the current one in the given line.
      Specified by:
        `setCurrentLine` in interface `GralTable_ifc<UserData>`
      Parameters:
        `line` - The line which should be selected.
        `ixline` - the index in the visible are of table where the line should be present. If the index is negative, it is the index from end of visible area. -1 means the last line. if the index is outside of the area, it will be set inside.
        `ixcolumn` - from 0 for the left column, if -1 then let the current row of table unchanged.

    - #### setColorBackSelectedLine

          public void setColorBackSelectedLine(GralColor color)

      Sets the color of the currently selected line.
      Parameters:
        `color` -

    - #### getCurrentLine

          public GralTable.TableLineData getCurrentLine()

      Returns the current selected line.
      Specified by:
        `getCurrentLine` in interface `GralTable_ifc<UserData>`

    - #### getLineMousePressed

          public GralTable.TableLineData getLineMousePressed()

      Returns the temporary selected line while pressing the mouse button. This method is able to use especially in mouse actions of user level. On pressing any mouse button the line on mouse position is set independent of the current line. The `#lineSelected()` is unchanged in this moment.
      Returns:
        The line where the mouse button is pressed.

    - #### getLine

          public GralTableLine_ifc<UserData> getLine(java.lang.String key)

      Description copied from interface: `GralTable_ifc`
      Get the line which is designated with the requested key. Background: The lines of a table can be sorted in view. To get a line which is sorted in another row a originally set a key is necessary. The table data model contains a sorted map with keys and the associated lines. The keys can, but may not shown as user visible data.
      Specified by:
        `getLine` in interface `GralTable_ifc<UserData>`
      Parameters:
        `key` - The key to find out the row.
      Returns:
        null if such line isn't found.

    - #### getCellTextFocus

          public java.lang.String getCellTextFocus()

      Gets the text of any cell which is in focus. This is a special routine: If no line is selected, it is possible that a text in a cell were written which is not assiciated to a line.
      Returns:

    - #### getIxLine

          public int getIxLine(GralTableLine_ifc<UserData> line)

      Gets the index in the visual presentation of the given line.
      Parameters:
        `line` - any line of this table, maybe null, maybe a line from any other table
      Returns:
        0 for the first line, 1..., -1 if not found respectively the line is not in the visible area. Return index of the first not defined line (current length of table) if line==null

    - #### insertLine

          public GralTable.TableLineData insertLine(java.lang.String lineKey,
                                                    int row,
                                                    java.lang.String[] lineTexts,
                                                    UserData userData)

      Description copied from interface: `GralTable_ifc`
      Inserts a line in the table with given content.
      Specified by:
        `insertLine` in interface `GralTable_ifc<UserData>`
      Parameters:
        `lineKey` - The key to get it.
        `row` - The row where the line should be inserted before. 0 - insert on top. negative or Integer.MAXINT or number greater as number of rows: append on end.
        `lineTexts` - texts of the cells. May be null.
        `userData` - data assigned to the line, able to get with `GralTableLine_ifc.getUserData()`.
      Returns:
        instance to add info.
      See Also:
        `GralTableLine_ifc} to add content.`

    - #### XXXinsertLine

          public GralTable.TableLineData XXXinsertLine(java.lang.String key,
                                                       int row,
                                                       java.lang.String[] cellTexts,
                                                       UserData userData)

    - #### addLine

          public GralTable.TableLineData addLine(java.lang.String lineKey,
                                                 java.lang.String[] lineTexts,
                                                 UserData userData)

      Description copied from interface: `GralTable_ifc`
      Inserts a line in the table with given content.
      Specified by:
        `addLine` in interface `GralTable_ifc<UserData>`
      Parameters:
        `lineKey` - The key to get it.
        `lineTexts` - texts of the cells. May be null.
        `userData` - data assigned to the line, maybe null, able to get with `GralTableLine_ifc.getUserData()`.
      Returns:
        instance to add info.
      See Also:
        `GralTableLine_ifc} to add content.`

    - #### XXXaddLine

          public GralTable.TableLineData XXXaddLine(java.lang.String key,
                                                    java.lang.String[] cellTexts,
                                                    UserData userData)

    - #### deleteLine

          public void deleteLine(GralTableLine_ifc<UserData> line)

      Description copied from interface: `GralTable_ifc`
      Deletes a line in the table.
      Specified by:
        `deleteLine` in interface `GralTable_ifc<UserData>`

    - #### iterLines

          public IterableIterator<GralTable.TableLineData> iterLines()

      Returns in iterable object for the lines which can used in a for-element expression or in a `Iterator` usage. Because the class `GralTable.TableLineData` implements the `GralTableLine_ifc` the user can write for example:

           for(GralTableLine_ifc line: widgTableVariables.iterLines()) {
              MyData data = line.getUserData();
              line.setBackColor(colorXY, 0);
            }

      Returns:

    - #### size

          public int size()

      Description copied from interface: `GralTable_ifc`
      Returns the number of active lines of the table.
      Specified by:
        `size` in interface `GralTable_ifc<UserData>`
      Returns:

    - #### clearTable

          public void clearTable()

      Specified by:
        `clearTable` in interface `GralTable_ifc<UserData>`

    - #### getMarkedLines

          public java.util.List<GralTableLine_ifc<UserData>> getMarkedLines(int mask)

      Description copied from interface: `GralTable_ifc`
      Returns all marked lines. It returns an empty list if no line is marked.
      Specified by:
        `getMarkedLines` in interface `GralTable_ifc<UserData>`

    - #### getAllLines

          public TreeNode_ifc<?,UserData> getAllLines()

      Description copied from interface: `GralTable_ifc`
      Returns all lines. Note: This returns the original container of lines without backup. It means the list will be changed if any `GralTable_ifc.insertLine(String, int, String[], Object)` or `GralTable_ifc.deleteLine(GralTableLine_ifc)` will be called. Do not call any modification of this list for example `List.add(Object)` or `List.remove(int)`, use the methods of this interface to change the content of the table. Elsewhere the graphical presentation of the data may be corrupted. See `GralTable_ifc.getListContent()`.
      Specified by:
        `getAllLines` in interface `GralTable_ifc<UserData>`

    - #### getListContent

          public java.util.List<UserData> getListContent()

      Description copied from interface: `GralTable_ifc`
      Returns all content of lines. This makes a snapshot of the lines in calling time. If the table will be changed in another thread while this routine runs, a `ConcurrentModificationException` will be thrown. But after them the list is able to use independently.
      Specified by:
        `getListContent` in interface `GralTable_ifc<UserData>`

    - #### getFirstMarkedLine

          public GralTableLine_ifc<UserData> getFirstMarkedLine(int mask)

      Description copied from interface: `GralTable_ifc`
      Returns the first line from top of the table which is marked or null if no line is marked.
      Specified by:
        `getFirstMarkedLine` in interface `GralTable_ifc<UserData>`

    - #### fillVisibleArea

          private void fillVisibleArea()

    - #### fillVisibleAreaBehind

          private void fillVisibleAreaBehind(GralTable.TableLineData lineStart,
                                             int ixStart)

    - #### shiftVisibleArea

          protected int shiftVisibleArea(int dLine)

      Shifts the content in `linesForCell` to show the appropriate part of data (e.g. lines of `rootLine`)in the table.
      Parameters:
        `dLine` - >0 shift up to get next lines, <0 shift down to get previous lines
      Returns:
        nr of lines shifted

    - #### nextLine

          GralTable.TableLineData nextLine(GralTable.TableLineData lineP)

    - #### prevLine

          GralTable.TableLineData prevLine(GralTable.TableLineData lineP)

    - #### mouseDown

          protected void mouseDown(int key,
                                   GralTable.CellData cell)

      Invoked in the graphic thread from mouse listener in `GraphicImplAccess#mouseDownGral(int, CellData)`
      Parameters:
        `key` -
        `cell` -

    - #### mouseUp

          protected void mouseUp(int key,
                                 GralTable.CellData cell)

      Invoked in the graphic thread from mouse listener in `GraphicImplAccess#mouseUpGral(int, CellData)`
      Parameters:
        `key` -
        `cell` -

    - #### mouseDouble

          protected void mouseDouble(int key,
                                     GralTable.CellData cell)

      Invoked in the graphic thread from mouse listener in `GraphicImplAccess#mouseDoubleGral(int, CellData)`
      Parameters:
        `key` -
        `cell` -

    - #### searchContent

          protected boolean searchContent(boolean bUp)

      Increments or decrements ixLineNew in [up] or [dn] situation until the `searchChars` are found or one time if searchChars are not given. If the searchChars are not found, either the first or last line will be selected. It is because any key operation should have an effect for the user. Paradigm: Not the search and found is prior, the response of operation is prior. The user may see whether anything is found.
      Parameters:
        `bUp` - direction
      Returns:
        true if found

    - #### checkAndUpdateText

          protected void checkAndUpdateText(java.lang.String sText,
                                            GralTable.CellData celldata)

      Invoked from focus lost of any table cell implementation, checks whether the line is changed.
      Parameters:
        `sText` - The text in the cell from the implementation widget.
        `celldata` - The cell, the line is gotten from `linesForCell`[`GralTable.CellData.ixCellLine`].

    - #### processKeys

          protected boolean processKeys(int keyCode)

      Handle all standard keys of table. It should call in the key event handler from the implementation class.
      Keys:
      - pgup:
      - up
      - dn
      - pgdn
      - `keyMarkUp`
      - `keyMarkDn`
      - calls `GralMng.getRegisteredUserAction(String what)` with what="KeyAction" and invokes the returned action method. With them all standard key actions of this application may be done if a `GralUserAction` is registered for that.
      Parameters:
        `keyCode` - Encoding see `KeyCode`.
      Returns:
        true if the key is processed, false if the key is not processed here. Maybe processed after them.

    - #### actionOnLineSelected

          private void actionOnLineSelected(int key,
                                            GralTableLine_ifc<?> line)

      It is called whenever another line is selected, if the focus is gotten by mouse click or a navigation key is pressed. This method calls the `GralUserAction.userActionGui(int, GralWidget, Object...)`. The `specifyActionOnLineSelected(GralUserAction)` can be set with any user instantiation of that interface. The params[0] of that routine are filled with the `GralTableLine_ifc` of the selected line.
      Parameters:
        `line` -

    - #### actionOnRefreshChildren

          protected void actionOnRefreshChildren(GralTableLine_ifc<?> line)

      It is called whenever another line is selected, if the focus is gotten by mouse click or a navigation key is pressed. This method calls the `GralUserAction.userActionGui(int, GralWidget, Object...)`. The `specifyActionOnLineSelected(GralUserAction)` can be set with any user instantiation of that interface. The params[0] of that routine are filled with the `GralTableLine_ifc` of the selected line.
      Parameters:
        `line` -