Smalltalk/X Webserver

Documentation of class 'DSVColumnView':

Class: DSVColumnView

Inheritance
Description
Class protocol
Instance protocol

Inheritance:

   Object
   |
   +--GraphicsMedium
      |
      +--DisplaySurface
         |
         +--SimpleView
            |
            +--View
               |
               +--DSVColumnView

Package:: stx:libwidg2

Category:: Views-DataSet

Version:: rev: 1.391 date: 2023/11/26 19:10:23; user: cg; file: DSVColumnView.st directory: libwidg2; module: stx stc-classLibrary: libwidg2

Description:

ColumnView part of a DataSetView.
implements a scrollable selection view based on rows and columns.
Used as the contents-part of a DataSetView.

[Instance variables:]

    editValue               <Model>                 current editing model
    editView                <View>                  current editing component

    buttonReleaseAction     <Action or nil>         called if the mouse button is released
    buttonMotionAction      <Action or nil>         called during mouse motion with one
                                                    argument the point under the mouse.

    multipleSelectOk        <Boolean>               multiple selection enabled/disabled

    selectedColIndex        <Integer>               selected column index or 0
    selectedRowIndex        <Integer>               selected row    index or 0

    rowHeight               <Integer>               maximum height of any row
    minRowHeight            <Integer>               minimum height of all displayed labels

    columnDescriptors       <SequancableCollection> list of column descriptors

    viewOrigin              <Point>                 current view origin

    colorMap                <Dictionary>            store and register used colors on device

    rowFontAscent           <SmallInteger>          inset of a printable text in a row
                                                    including separator and font ascent.

    lockRowIndex            <SmallInteger>          internal used to indicate a row which has
                                                    changed its contents but no redraw should be
                                                    done( at:put: ).

    columnHolder            <ValueHolder>           holder which keeps the list of column descriptors.

    registererImages        <IdentityDictionary>    list of images registered on the device

    list                    <SequancableCollection> list of rows


    catchChangeEvents       <Boolean>               internal used to discard change notifications

    beDependentOfRows       <Boolean>               keep rows dependent; by default is disabled.
                                                    in case of enabled a row can raise a change
                                                    notification whithout a parameter which
                                                    will force a redraw of the row or the
                                                    readSelector of the column which will
                                                    redraw the cell in the row only.

    fgColor                 <Color>                 foreground color
    bgColor                 <Color>                 background color
    hgLgFgColor             <Color>                 highlight foreground color (selected)
    hgLgBgColor             <Color>                 highlight background color (selected)

    buttonLightColor        <Color>                 LightColor      ( drawing the edge of a button )
    buttonShadowColor       <Color>                 ShadowColor     ( drawing the edge of a button )
    buttonHalfLightColor    <Color>                 HalfLightColor  ( drawing the edge of a button )
    buttonHalfShadowColor   <Color>                 HalfShadowColor ( drawing the edge of a button )

    actionBlock             <a OneArgBlock>         action block performed on select
    doubleClickActionBlock  <a OneArgBlock>         action block performed on double click
    rowIfAbsentBlock        <a OneArgBlock>         this block is performed on an empty list entry
                                                    to retrive the item from the application. The
                                                    argument to the block is the index into the list.
                                                    The block should return the row instance which
                                                    is put to the list under the index.

    builder                 <UIBuilder>             builder set by application

    verticalSpacing         <SmallInteger>          vertical   row spacing( top  & bottom )
    horizontalSpacing       <SmallInteger>          horizontal row spacing( left & right )
    separatorSize           <SmallInteger>          line width of a vertical or horizontal separator

    rowSelectorForm         <Form>                  form used by a row selector

    checkToggleForm         <Form>                  form used by a checkToggle
    checkToggleExtent       <Point>                 extent of a checkToggle
    checkToggleLevel        <SmallInteger>          level used to draw a check toggle

    comboButtonForm         <Form>                  form used by a comboList or -Box
    comboButtonExtent       <Point>                 extent of a comboList or -Box
    comboButtonLevel        <SmallInteger>          level used to draw a comboList or -Box

    dropTarget              <DropTarget>            drag & drop target
    dropSource              <DropSource>            drag & drop source

copyrightCOPYRIGHT (c) 1997 by Claus Gittinger / eXept Software AG
             All Rights Reserved

This software is furnished under a license and may be used
only in accordance with the terms of that license and with the
inclusion of the above copyright notice.   This software may not
be provided or otherwise made available to, or used by, any
other person.  No title to or ownership of the software is
hereby transferred.

Class protocol:

defaults

defaultFont

horizontalSpacing

returns the default horizontal space between rows

preselectAllWhenOpeningEditor: aBoolean

updateStyleCache

extract values from the styleSheet and cache them in class variables

Usage example(s):

     self updateStyleCache.

verticalSpacing

returns the default vertical space between rows

image specs

dragIconMulti

This resource specification was automatically generated
by the ImageEditor of ST/X.

Usage example(s):

     self dragIconMulti inspect
     ImageEditor openOnClass:self andSelector:#dragIconMulti
     Icon flushCachedIcons

dragIconSingle

This resource specification was automatically generated
by the ImageEditor of ST/X.

Usage example(s):

     self dragIconSingle inspect
     ImageEditor openOnClass:self andSelector:#dragIconSingle
     Icon flushCachedIcons

rowSelectorImage

This resource specification was automatically generated
by the ImageEditor of ST/X.

Usage example(s):

     self rowSelectorImage inspect
     ImageEditor openOnClass:self andSelector:#rowSelectorImage
     Icon flushCachedIcons

signal constants

stopRedrawSignal: returns the signal which is raised during drawing if the
required label height is less than the current rowHeight

Instance protocol:

accessing

builder

get the builder (UIBuilder or nil)

builder: aBuilder

set the builder (UIBuilder or nil)

columnView

returns self

labelView

labelView: aView

level: aLevel

change the level and thus the level of the labelView

Usage example(s):

labelView level:aLevel.

preferredLabelViewHeight

+ (labelView margin + self verticalSpacing * 2).

rowFontAscent

returns the inset of a printable text in a row

selectedColIndex: newSelectedColIndex

selectedColIndexHolder

accessing-actions

action: aOneArgAction: set the action block to be performed on select
doubleClickAction: aOneArgAction: set the action block to be performed on doubleclick
rowIfAbsent: aOneArgAction: set the action block to be performed on each 'nil' entry into the
list. The argument to the block is the index into the list. The
block returns the row which is put to the list
selectConditionBlock: get the select-conditionBlock; this block is evaluated before
any selection change is performed (passing the to-be-changed row number
index as arg).
The change will not be done, if the block returns false.
selectConditionBlock: aOneArgBlockOrNil: set the select-conditionBlock; this block is evaluated before
any selection change is performed (passing the to-be-changed row number
index as arg).
The change will not be done, if the block returns false.
tabAtEndAction: aNoneArgAction: set the action, called without any argument at end of the list entering
tab next.
The default is to give the focus to the view after self in the focusSequence
tabAtStartAction: aNoneArgAction: set the action, called without any argument at start of the list entering
tab previous.
The default is to give the focus to the view before self in the focusSequence

accessing-behavior

autoScrollToColumn: return true, if I scroll to the column, when one is selected.
autoScrollToColumn: aBoolean: control, if I should scroll to the column, when one is selected.
The default is true
beDependentOfRows: make myself dependent of any row; in this case any change notification
raised by a row is catched and the cell identified by the 'readSelector'
is redrawn. In case of a nil readSelector, the whole raw is redrawn.
-> row changed:'what'
By default, the attribute is set to false (disabled).
beDependentOfRows: aBool: make myself dependent of any row; in this case any change notification
raised by a row is catched and the cell identified by the 'readSelector'
is redrawn. In case of a nil readSelector, the whole raw is redrawn.
-> row changed:'what'
By default, the attribute is set to false (disabled).
enableChannel: aChannel: (comment from inherited method)
set the valueHolder, which holds the enable boolean value
ignoreReselect: controls if clicking on an already selected item should
be ignored or should perform the select action again.
By default, these are ignored
ignoreReselect: aBoolean: controls if clicking on an already selected item should
be ignored or should perform the select action again.
By default, these are ignored
makeDependentOfRows: make myself dependent of any row
makeIndependentOfRows: make myself independent of any row
multipleSelectOk: allow/disallow multiple row selections; the default is false
multipleSelectOk: sBoolean: allow/disallow multiple row selections; the default is false
opaqueColumnResize
opaqueColumnResize: aBoolean
scrollWhenUpdating: return the scroll behavior, when I get a new text
(via the model or the #contents/#list)
Possible returnValues are:
#keep / nil -> no change
#endOfText -> scroll to the end
#beginOfText -> scroll to the top
The default is #beginOfText.
This may be useful for fields which get new values assigned from
the program (i.e. not from the user)
scrollWhenUpdating: aSymbolOrNil: define how to scroll, when I get a new text
(via the model or the #contents/#list)
Allowed arguments are:
#keep / nil -> no change
#endOfText -> scroll to the end
#beginOfText -> scroll to the top
The default is #beginOfText.
This may be useful for fields which get new values assigned from
the program (i.e. not from the user)
selectRowOnDefault: if true, in case of selecting a none selectable cell, the row is selected.
If false, nothing is selected. The default is true.
selectRowOnDefault: aBool: if true, in case of selecting a none selectable cell, the row is selected.
If false, nothing is selected. The default is true.
sortListInPlace: when false (default for backward compatibility):
if sorting, create a copy
of the list, which is wrong when useIndex is on,
as the application will get the index in the sorted
list, which is probably different from tha apps list mode.
When true (should be default, but that might break many
users), the passed in list is sorted in place (i.e. possibly
sorting the application's list).
sortListInPlace: aBoolean: when false (default for backward compatibility):
if sorting, create a copy
of the list, which is wrong when useIndex is on,
as the application will get the index in the sorted
list, which is probably different from tha apps list mode.
When true (should be default, but that might break many
users), the passed in list is sorted in place (i.e. possibly
sorting the application's list).
tabIntern: returns true if tabing is supported in the widget
tabIntern: aBool: returns true if tabing is supported in the widget
updateListHolderWhenSorting: return true if the the listHolder's value are be updated,
when I sort a list.
By default, this is false so it must be set explicitly
(for bug-backward compatibility,
and to avoid introducing new side effects).
updateListHolderWhenSorting: aBoolean: define if the the listHolder's value should be updated,
when I sort a list.
By default, this is false so it must be set explicitly
(for bug-backward compatibility,
and to avoid introducing new side effects).
useIndex: specify, if the selected components value or its index in the
list should be sent to the model. The default is its index.
useIndex: aBool: specify, if the selected components value or its index in the
list should be sent to the model. The default is its index.

accessing-channels

modifiedChannel
modifiedChannel: something

accessing-color & font

backgroundColor: get the background color of the rows
backgroundColor: aColor: set the background color of the rows
foregroundColor: return the foreground color of the rows
foregroundColor: aColor: set the foreground color of the rows
labelBackgroundColor: get the background color of the label row
labelForegroundColor: get the foreground color of the label row
selectionBackgroundColor: returns the background color of a selected row
selectionForegroundColor: returns the foreground color of a selected row
selectionFrameColor: returns the frame color of a selected row
separatorDarkColor: returns the dark color used for drawing a shadowed separator (3D)
separatorLightColor: returns the light color used for drawing a shadowed separator (3D)
separatorOneDColor: returns the color used for drawing a oneD separator
separatorOneDColor: aColorOrNil: set the color used for drawing a oneD separator; if the color
is nil, the current forgroundColor is used

accessing-columns

columnAt: anIndex: returns the column at an index

** This is an obsolete interface - do not use it (it may vanish in future versions) **
columnDescriptorAt: anIndex: returns the columnDescriptor at an index
columnDescriptors: returns list of column descriptors
columnDescriptors: aColumnDescriptionList: set the columnDescriptors;
scroll to top and deselect
columnDescriptors: aColumnDescriptionList deselect: deselect scrollToTop: scrollToTop: set the columnDescriptors;
if deselect is true, then deselect;
if scrollToTop is true, then scroll to top;
otherwise, take the current selection and try to make it visible
columnDescriptors: aColumnDescriptionList scrollToTop: scrollToTop: set the columnDescriptors and deselect;
if scrollToTop is true, then scroll to top;
otherwise, take the current selection and try to make it visible
dataSetColumns: returns the list of DataSetColumns; each column represents a DataSetColumnSpec
firstColumn: returns the first column
lastColumn: returns the last column
setColumnDescriptors: aColumnDescriptionList: set the columnDescriptors; don't deselect and do not scroll to top

accessing-interactors

checkToggleActiveImage
checkToggleExtent: returns the extent of a checkToggle
checkToggleForm: returns the form of a checkToggle
checkToggleLevel: returns the level of a checkToggle button
checkTogglePassiveImage
comboButtonExtent: returns the extent of a comboList or -Box
comboButtonForm: returns the form of a comboList or -Box
comboButtonLevel: returns the level of a comboList or -Box button
radioButtonExtent: returns the extent of a radio button
rowSelectorExtent: returns the bitmap of a selected row
rowSelectorForm: returns the (arrow-) image shown for a selected row.
(the arrow shown in the first column)

accessing-mvc

columnAdaptor: If non-nil, messages to fetch/store columns from a model-list's element
will be sent to the adapter (i.e. it can map or compute values).
Use #yourself to let the application itself access the columns.
Use nil or leave empty, to have messages been sent directly to the row element.
The per-column getter/setter messages are specified in the columnSpecification.
columnAdaptor: usuallyAnApplication: If non-nil, messages to fetch/store columns from a model-list's element
will be sent to the adapter (i.e. it can map or compute values).
Use #yourself to let the application itself access the columns.
Use nil or leave empty, to have messages been sent directly to the row element.
The per-column getter/setter messages are specified in the columnSpecification.
columnHolder: get the valueHolder, which keeps the list of column descriptions
columnHolder: aValueHolder: set the valueHolder, which keeps the list of column descriptions
listAt: index put: newElement: kludge callback, when an element hs to be replaced
due to a col-adaptor returning a new row element
listHolder: get the valueHolder which holds the list of rows
listHolder: aListHolder: set the valueHolder which holds the list of rows
model: aModel: set the valueHolder which holds the selection and maybe the list of rows

accessing-rows

at: aRowNr: return the row at an index, aRowNr
at: aRowNr ifAbsent: exceptionBlock: return the row at a aRowNr. If the index is invalid, return the
result of evaluating the exceptionblock
at: aRowNr put: aRow: change the row at an index. The added row is returned
first: return the first row
identityIndexOfRow: aRow: returns index of a row or 0
last: return the last row
list: get the list of rows
list: aRawList: set the list of rows

accessing-visibility

font: aFont: set the font for all shown rows.
has3Dseparators: returns true if shown in 3D mode
has3Dseparators: aBool: enable or disable 3D mode
horizontalSpacing: horizontal spacing used by columns
horizontalSpacing: aNumber: horizontal spacing used by columns
showLabels: control the labels view to be visible or unvisible
showLabels: aBoolean: control the labels view to be visible or unvisible
verticalSpacing: vertical spacing used by columns
verticalSpacing: aNumber: vertical spacing used by columns

adding & removing rows

add: aRow: insert aRow at the end (i.e. append)
add: aRow afterIndex: rowNrToInsertAfter: add a new row after slot aRowNr and redisplay; returns nil in case
of an invalid index or the row
add: aRow beforeIndex: rowNrToInsertBefore: add a new row before slot aRowNr and redisplay; returns nil in case
of an invalid index or the row
addAll: aCollectionOfRows beforeIndex: rowNrToInsertBefore: add a collection of rows before index rowIndexToInsertBefore and redisplay
addFirst: aRow: insert a row at start
remove: aRow: remove a row
removeFirst: remove first row; returns the removed row
removeFrom: startIndex to: stopIndex: remove rows from start to stop
removeIndex: aRowNr: remove row at an index.
Returns the removed row
removeLast: remove last row; the row is returned
replaceFrom: start to: stop with: aCollection startingAt: repStart: replace elements in the receiver between index start and stop,
with elements taken from aCollection starting at repStart.
Return the receiver.

change & update

changeWidthOfColumn: aColumn deltaX: aDeltaX
update: anAspect with: aParameter from: changedObject: one of my rows/cells changed its value
updateColumnFromEditValue: turn off the other column
updateEditorFromChangedRow
updateList

drag & drop

canDrag: returns true if dragging is enabled
canStartDragAt: aPoint clickedAt: clickPoint
dragAutoScroll: aDropContext: called by the DragAndDropManager to scroll during a drag/drop operation
if required (decided by the widget itself).
If a scroll is done, return true;
otherwise false (used to restore the background)
dropSource: returns the dropSource or nil
dropSource: aDropSourceOrNil: set the dropSource or nil
startDragAt: aPoint

drawing

colorOnDevice: aColor: returns color on device
forceRedraw: a redraw forced by any other component
invalidate: recompute extent before repair range
invalidateRowAt: aRowNr: redraw total row at an index
invalidateRowAt: aRowNr colAt: aColNr: redraw either a single column in a row,
or the complete visible row (in case of aColNr == 0).
If the row/column is hidden, no redraw is done
invalidateRows: aCollection: redraw some visible rows
invalidateRowsFrom: aStart to: aStop: redraw visible row from start to stop
invalidateSelection: invalidate (force async redraw) the current selection
invalidateVisibleRow: aRow: redraw row if visible
invalidateVisibleRow: aRow colAt: aColNr: redraw either a single column in a row,
or the complete visible row (in case of aColNr == 0).
If the row/column is hidden, no redraw is done
invalidateVisibleRow: aRow readSelector: aSelector: redraw a column identified by its read selector; if no column with
the specified read selector is detected, the whole line is drawn.
redrawX: x y: y width: w height: h: redraw part of myself immediately, given logical coordinates

drawing interactors

displayLabel: aLabel x: xLeft y: yTop: display the label at x y; test whether the height of the label matches to the current
rowHeight. If not, an exception is raised and the rowHeight is recomputed
drawCheckToggleAtX: xLeft y: yTop w: cellWidth state: cellValue: draw a check toggle button
drawComboButtonAtX: xTop y: yTop w: rowWidth: draw a combo button
drawEdgesAtX: x y: y width: w height: h level: aLevel on: aGC: draw edges for a cell or label
drawRadioButtonAtX: xLeft y: yTop w: cellWidth state: aBooleanOrNil: draw a radio button

enumerating columns

columnsDo: aOneArgBlock: evaluate the argument, aOneArgBlock for every columnDescriptor
columnsFrom: start to: stop do: aOneArgBlock: evaluate the argument, aOneArgBlock for the columns with index start to
stop in the collection of column descriptors

event handling

buttonControlPressAt: clickPoint rowNr: aRowNr colNr: aColNr
buttonMotion: buttonMask x: x y: y: mouse-move while button was pressed - handle multiple selection changes
buttonMultiPress: button x: x y: y: a button was pressed twice - handle doubleclick here
buttonPress: button x: x y: y: a button was pressed - handle selection here
buttonRelease: button x: x y: y: (comment from inherited method)
button was released - check my components for a hit.
buttonShiftPressAt: clickPoint rowNr: aRowNr colNr: aColNr: toggle column selection
characterPress: aChar x: x y: y: search row in column at x/y starting its printable label with character.
contentsChanged: size of contents changed - move origin up if possible
cursorKey: aKey rawKey: rawKey: aKey == #BeginOfLine or:[
doubleClicked: handle a double click
findMenuForSelection: find the middle button menu for the current selection; returns the menu or nil
keyPress: aKey x: x y: y: a key was pressed - handle page-keys here
keyboardZoom: largerBoolean: ALT+/- (was: CTRL+/-) zoom action
mouseWheelZoom: amount: CTRL-wheel action
originChanged: delta: this one is sent, after the origin of my contents has changed -
tell dependents (i.e. scrollers) about this
scrollToEnd
sizeChanged: how from: oldExtentOrNil: my view has changed the size (not the contents);
move origin up if possible
change the layout of the labelView dependent on my layout
visibilityChange: how: expeccoalm.exept.de/D521870
TableColumnView / DSV View: initiale ColumnWidth falsch

focus handling

canTab: (comment from inherited method)
returns true if the widget is tabable
showFocus: explicit: (comment from inherited method)
highlight myself somehow to tell user that I have the focus.
If explicit is true, the focus came via focusStepping (i.e. tabbing);
if false, it came via the window manager (i.e. pointer entering).
Only change my border, if this is an explicit focusChange.
showNoFocus: explicit: (comment from inherited method)
undo the effect of showFocus.
Explicit tells if the focus came via focusStepping (i.e. tabbing)
or via the window manager (i.e. pointer entering).
Only change my border, if this is an explicit focusChange.
wantsFocusWithPointerEnter: views which like to take the keyboard focus
when the pointer enters can do so by redefining this
to return true

gc operations

imageOnMyDevice: anImage: associate image to device and returns the new image.
registerImage: anImage key: aKey: any row can register an image with a unique identifier a key symbol
registeredImageAt: aKey: any row can register an image with a unique identifier
releaseAllRegisteredImages: release all registered images

help

helpTextAt: aPoint: return the helpText for aPoint (i.e. when mouse-pointer is moved over an item).

initialization & release

create: (comment from inherited method)
create (i.e. tell my device about me) if not already created.
This does not make the view visible (needs a #map for that)
initStyle: setup colors, etc.
initialize: set default attributes
mapped: set selection (if any) after mapping
realize: recompute contents and fit columns to view
release: remove dependencies

obsolete

has3Dsepartors: shouldn't be used any more

** This is an obsolete interface - do not use it (it may vanish in future versions) **
has3Dsepartors: aBool: shouldn't be used any more

** This is an obsolete interface - do not use it (it may vanish in future versions) **

private

anyColumnHasBackground

anyColumnHasPotentialNonConstantBackground

columnDescriptors do:[:eachCol | eachCol hasPotentialNonConstantBackground ifTrue:[^ true]].

destroyEditView

destroy the edit view; release KeyboardForwarder

detectViewAt: aPoint in: aView

returns the view at a point

fitColumns

fit columns to view;

Usage example(s):

have to invalidate unconditionally even if nothing has been changed here:
         #fitColumns is called from #changeWidthOfColumn:deltaX:
         after a manual resize

hasSelectables

maxViewOriginY

returns the maximum possible y of the view origin

updateEditViewOrigin

update origin of the editView

xVisibleOfColNr: aColNr

returns visible x assigned to a column number

xVisibleToColNr: x

returns the column number for a physical x position.
Returns nil if x is beyond the last column.

yVisibleOfRowNr: aRowNr

returns visible y assigned to the row number

yVisibleToRowNr: y

returns the row number assigned to a physical y or nil

queries

firstLineShown: for protocol-compat. with listviews
hasOpenEditor
indexOfFirstRowShown: returns the index of the first shown row
indexOfLastRowShown: returns the index of the last shown row
isEnabled: (comment from inherited method)
return true, if this view is enabled (i.e. accepts user interaction).
Most views are enabled - only a few (buttons, SelectionInList etc.) can
be disabled.
#isEnabled is ST-80's equivalent of #enabled
isRowSelectable: aRowNumber: returne true if a row number is selectable
numberOfColumns: returns number of columns
numberOfRows: returns number of rows
rowHeight: get the height of the highest row in pixels
separatorSize: returns vertical/horizontal size of a separator dependent on the
3D effect.
size: returns number of rows
yVisibleToLineNr: yVisible

queries-contents

heightOfContents: return the height of the contents in pixels
widthOfContents: return the width of the contents in pixels

recomputation

computePreferredExtent: return my preferred extent
computeRowHeight: to fix a double bug which compensated for not computing things correctly
hasPreferredExtent: returns true if preferred extent is accumulated
preferredExtentChanged: called if the preferred extent changed
recomputeHeightOfContents: recompute height of contents( scrolling )

scroller interface

innerHeight: returns the inner height of the contents shown
verticalScrollStep: return the amount to scroll when stepping up/down (also used for mouseWheel).
viewOrigin: return the viewOrigin;
that's the coordinate of the contents which is shown topLeft in the view.
xOriginOfContents: return the horizontal origin of the contents in pixels
yOriginOfContents: return the vertical origin of the contents in pixels

scrolling

scrollTo: anOrigin redraw: doRedraw: change origin to have newOrigin be visible at the top-left.
scrollToLine: aLineNr: for compat. with listViews
scrollToRowAt: aRowNr colAt: aColNr: make row at a row number in column at a column number visible
scrollToSelection: make selection visible
scrollVerticalTo: aPixelOffset: change origin to make aPixelOffset be the top line
startAutoScroll: aSelectorOrBlock distance: aDistance: setup for auto-scroll (when button-press-moving below/above view);
- timeDelta for scroll is computed from distance
stopAutoScroll: stop any autoScroll

searching

findFirstColumnWithStringFrom: start to: stop
findFirstRowFrom: start to: stop withString: aString inColumn: colNr
findFirstRowWithString: aString from: start to: stop by: step ignoreCase: ignoreCase: Return the rowNr from the first row that matches aString.
The search is performed between the start and stop row numbers and incrementing by a step
findFirstRowWithString: aString from: start to: stop ignoreCase: ignoreCase: Return the rowNr from the first row that matches aString.
The search is performed between the start and stop row numbers
findFirstRowWithString: aString inColumn: colNr

selection

addRowToSelection: aRowNr: add a row to the selection
if a column is selected, the column will be closed
deselect
firstIndexSelected: returns index of first row selected or 0
forceAcceptInEditor
hasRowSelection: returns true if a selection exists, and its a complete row
(as opposed to either no selection, or a columnSelection)
hasSelection: returns true if a selection exists
isInSelection: aRowNr: returns true, if row, aRowNr is in the selection
isRowSelected: aRowNr: returns true, if row is in the selection
isRowVisible: aRowNr
isSelected: aRowNr inColumn: aColNr: returns true if cell in a row; a row number, in a column, a column
number is selected.
isSelectionVisibleIn: anExtentPoint
lastIndexSelected: returns index of last selected row or 0
makeLineVisible: aLineNr: scroll to make aLineNr visible;
if it is already visible, do nothing
makeSelectionVisible: scroll to make the selection line visible;
cg@ca: not exactly clear, what happens, if it is already visible
does it scroll it to the top, the bottom, or does it not scroll at all?
maxIndexSelected: return the largest index selected or 0
minIndexSelected: return the smallest index selected or 0
numberOfSelections: return the number of selected rows
openEditorOnSelection: editorAndModel acceptAction value:nil.
processAllExposeEvents
removeRowFromSelection: aRowNr: remove a row from the selection
selectAllRows: select all
selectColIndex: aColNr rowIndex: aRowNr: change selection to a single column, possibly opening an editor there.
With notification
selectColIndex: aColNr rowIndex: aRowNr openEditor: openEditor: change selection to a single column, possibly opening an editor there.
With notification
selectRow: anInteger: select a row
selectRowAt: rowNr colAt: colNr atPoint: aPoint
selectRowAt: rowNr colAt: colNr atPoint: aPoint openEditor: openEditor: might be a reselection
selectRowFrom: start to: stop
selectRowIndex: anInteger: set the selected row (selected col remains unchanged)
selectedColIndex: returns selected column number or 0
selectedColumn: returns selected column or nil
selectedRow: returns the selected row (or collection if multiple selection) or nil
selectedRow: rowNr: select rowNr
selectedRowIndex: bad name: may return a collection (if multiSelect is enabled)
returns the selected row number or 0 (if singleSelect)
or a collection of selected row numbers or #() (if multiSelect)
selectedRowIndex: rowNrOrCollectionOfRowNrs: set the row selection (single or multiple rows);
does NOT change the selected column.
selectionChanged: selection has changed
selectionChanged: colNrOrNil: selection has changed
selectionIndicesDo: aOneArgBlock: evaluate block on each row selected; the argument to the row
is the index of the selected row
setSelectColIndex: colNrArg rowIndex: rowNrArg: change selection without notification
setSelectColIndex: colNrArg rowIndex: rowNrArg openEditor: openEditor: change selection without notification
updateColumnFromEditValueAndDestroyEditView: ??? should we do ???:
validateSelection: aSelection: multiple selection

ST/X 7.7.0.0; WebServer 1.702 at 20f6060372b9.unknown:8081; Mon, 18 Nov 2024 04:20:38 GMT