1topic "ArrayCtrl"; 2[i448;a25;kKO9;2 $$1,0#37138531426314131252341829483380:class] 3[l288;2 $$2,2#27521748481378242620020725143825:desc] 4[0 $$3,0#96390100711032703541132217272105:end] 5[H6;0 $$4,0#05600065144404261032431302351956:begin] 6[i448;a25;kKO9;2 $$5,0#37138531426314131252341829483370:item] 7[l288;a4;*@5;1 $$6,6#70004532496200323422659154056402:requirement] 8[l288;i1121;b17;O9;~~~.1408;2 $$7,0#10431211400427159095818037425705:param] 9[i448;b42;O9;2 $$8,8#61672508125594000341940100500538:tparam] 10[b42;2 $$9,9#13035079074754324216151401829390:normal] 11[2 $$0,0#00000000000000000000000000000000:Default] 12[{_}%EN-US 13[ {{10000t/25b/25@3 [s0; [*@(229)4 ArrayCtrl]]}}&] 14[s5;K &] 15[s0; 16@@image:2362&1443 17(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) 18&] 19[s0;*@3;3 &] 20[s1;:ArrayCtrl`:`:class: [@(0.0.255)3 class][3 _][*3 ArrayCtrl][3 _:_][@(0.0.255)3 public][3 _][*@3;3 C 21trl]&] 22[s1; &] 23[s0; [* 24@@image:1843&731 25(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) 26]&] 27[s0;* &] 28[s0; [* ArrayCtrl] implements basic grid functionality. It is typically 29used for display and editing of arrays of values or (heterogeneous) 30records. The records correspond to rows in the array, the individual 31fields within each record can be either bound to columns or to 32any generic [* Ctrl]`'s, thus supporting basic master`-detail functionality 33with practically no additional cost.&] 34[s0; &] 35[s0; The standard derived classes extend various aspects of the ArrayCtrl 36functionality. [* SqlArray] adds the nuts and bolts needed for 37editing SQL`-based tables, whereas [* PopupTable] couples the ArrayCtrl 38functionality with the drop`-down mechanism very similar to the 39one used in popup menus. This opens the door for implementing 40drop`-down controls like [* DropList] (aka [/ combo box]) or [* DropChoice] 41(usually used together with a control of the [* EditField ]or [* DataPusher] 42family to support coupling native data editing with drop`-down 43selection, widely used for history or commonly used predefined 44values. The [* ArrayPair] is, as its name implies, a pair of [* ArrayCtrl]`'s 45with arrow buttons between them allowing to visually select subsets 46of a certain set by moving its elements between the two lists.&] 47[s0; &] 48[s0; [*+117 The array data organization: indices and columns]&] 49[s0; &] 50[s0; There is a great deal of genericity supported by the ArrayCtrl 51with respect both to its source data and its visual presentation. 52Conceptually, the source array data is a matrix of [* Value]`'s. 53There is a series of methods for accessing this source data, 54the basic ones being [* Set] and [* Get]. The rows are addressed 55by integer indices (zero based), the columns can be addressed 56either by integer indices as well, or alternatively any source 57column can be assigned an [* Id] identifier and addressed by it. 58This is especially helpful in SQL`-based tables, where the table 59column names can be used for the [* Id]`'s. A pair of methods, 60[* GetPos] and [* GetId], can be used to translate these two column 61addressing modes. In the code terminology, the columns in the 62source data matrix are called [/ indices] whereas the visual (output) 63columns are called simply [/ columns].&] 64[s0; &] 65[s0; The visual ArrayCtrl structure can be entirely independent of 66the source data structure (although it`'s seldom helpful to make 67the mapping completely arbitrary). Basically, each column can 68have an arbitrary number of indices defining its source data. 69Of course, the most common case is one index per column. This 70is also simplest to address, because the column indices are equal 71to the source data indices. However, many other combinations 72are possible, each of which can be handy in certain situations:&] 73[s0; &] 74[s0;i150;O0; Index without a column: the most common of the `"special`" 75cases is used mainly for row id`'s or other internally important 76data without visual representation. The same behaviour can be 77obtained by making a column invisible.&] 78[s0;i150;O0; Column without an index (a [/ rownum column]): this less 79common case can be used to display external data (not stored 80in the table). &] 81[s0;i150;O0; Multiple columns sharing the same index: this can be 82used to display various aspects of a complex data object or to 83display the same source data in multiple ways (e.g., a temperature 84reading in Celsius and Fahrenheit degrees).&] 85[s0;i150;O0; Column with multiple indices: can be used to display 86information gathered from multiple source data columns. This 87is used for instance in IconDes in TheIDE to display image identifiers 88together with their sizes in the list. This is the most complicated 89case because you have to implement a specific [* Display] for such 90a multi`-index column.&] 91[s0; &] 92[s0; [* Note:] in the current U`+`+ version, the implementation of index`-less 93columns (arrays with external data not stored in the source matrix) 94is rather awkward. It is planned to enhance this feature in the 95future by adding support for access to external data via a data 96accessor interface object. &] 97[s0; &] 98[s0; [*+117 ArrayCtrl GUI: selection, editing, and local menu]&] 99[s0; &] 100[s0; Array rows can be selected using the mouse or keyboard. ArrayCtrl`'s 101support both single`-selection (plain cursor) and multiselection 102model. Of course, row selection can be controlled via the programmatic 103array interface as well. The selection and cursor always spans 104entire rows, it is not possible (without substantial patchwork) 105to select only certain columns or individual cells.&] 106[s0; &] 107[s0; The ArrayCtrl rows can be inserted, edited and deleted either 108programmatically, or via common GUI elements (mouse and keyboard 109selection, local menu). It is possible to alter the standard 110ArrayCtrl local menu using the [* WhenBar] callback.&] 111[s0; &] 112[s0; [* Note:] it is worth noting that the standard editing keys ([* Insert] 113`= row insertion, [* Ctrl`+Enter] `= editing and [* Ctrl`+Delete] 114`= deletion) are not hardcoded in the ArrayCtrl`'s [* Key] method, 115they are mere hotkeys for the relevant local menu items. When 116you change the ArrayCtrl`'s local menu, the editing hotkeys change 117accordingly.&] 118[s0; &] 119[s0; A special but rather important case of array editing is [/ sorting]: 120there is no specific standard GUI for that. If you aren`'t content 121with programmatic sorting (e.g. after opening a dialog or after 122loading the array data), you have to implement some GUI for that 123as well. In certain cases, it is cool to use the [* HeaderCtrl] 124[* WhenAction] method to allow sorting the array by clicking on 125the header columns; alternatively you can add a sort function 126to the array local menu or possibly somewhere else (like a standalone 127button in the dialog).&] 128[s0; &] 129[s0; [* Insertion tricks: before, after, and the secrets of the AppendLine]&] 130[s0; &] 131[s0; In todays text editors, when you type a new letter, it is trivial 132to see where in the text will the new letter go. This is so because 133the caret is always positioned between a pair of successive letters 134and thus is well defines the insertion spot. Additionally, the 135caret can be placed in front of the first letter or after the 136last letter, which naturally allows typing some text at the very 137beginning or end.&] 138[s0; &] 139[s0; When inserting new rows into the array controls, things are 140a bit more tricky. This is so because, unlike in the text editor, 141the cursor is not placed [/ between] two successive rows, but [/ over] 142a certain row. This is of course necessary to make row editing 143possible (note that in the aforementioned text editor analogy, 144a single letter is an atomic object whereas in the array it is 145a potentially complex structure consisting of many columns and 146data items). However, when it comes to row insertion, it has 147two main troubles as its implication:&] 148[s0; &] 149[s0;i150;O9; [* 1.]-|It is necessary to decide somehow whether the new 150row will go [/ above] or [/ below] the cursor row.&] 151[s0;i150;O9; [* 2.]-|In an array with [/ n] rows, there are [/ n`+1] possible 152locations for a new row (before the row #0, #1 ... #([/ n`-1]) 153and after the last row), but only [/ n] distinct cursor locations.&] 154[s0; &] 155[s0; Over the years, during the development of U`+`+, we experimented 156with multiple ways to overcome these logical problems. As a result 157of this, the ArrayCtrl supports a few methods allowing to fine`-tune 158the row insertion mechanism. It is also worth noting that there 159are cases, like in the case of SQL`-based tables, where the row 160ordering is arbitrary or implicit and the exact `'location`' 161of a new row doesn`'t make any sense. In such cases, it is possible 162to replace array [/ insertion] function with the [/ append] function 163emphasizing the fact that the visual row order is unimportant 164and that insertion means merely adding a new record to the record 165set.&] 166[s0; &] 167[s0; For arrays in which the order is important, there are two ways 168to solve the [/ n`+1] row positions dilemma:&] 169[s0; &] 170[s0;i150;O9; [* 1.]-|Replacing the Insert function with a pair of functions 171for inserting a new row [/ before] / [/ after] the current row.&] 172[s0;i150;O9; [* 2.]-|Visually extending the array by adding a pseudo`-row 173with no real data at its end; this creates the [/ n`+1]`-th cursor 174position necessary to denote all the available row insertion 175locations.&] 176[s0; &] 177[s0; In the first case, it is also possible to select which of the 178insertion functions (before / after) takes precedence (which 179of the two actions should be bound to the standard [* Insert] hotkey). 180This corresponds to the [* BeforeAfterInserting] and [* AfterBeforeInserting] 181methods. The second case is called the [* AppendLine] and is activated 182by setting the property with the same name.&] 183[s0; &] 184[s0; To make all this even more interesting, a special mechanism 185called [* InsertAppend] is available to make array filling as easy 186as possible. When activated and the user appends a new row at 187the table end, after pressing [* Enter] (to commit the inserted 188row) another row is automatically added after it and opened for 189editing. This mechanism is turned on by default, but it can be 190disable by setting the [* NoInsertAppend] property to true.&] 191[s3; &] 192[s0; &] 193[s0; &] 194[ {{10000t/25b/25@3 [s0; [*@(229)4 Categorized method summary]]}}&] 195[s9; The following table summarizes ArrayCtrl methods according to 196the aspect of functionality they support together with a very 197brief description. For more thorough documentation of the individual 198methods see below.&] 199[s0; &] 200[ {{2337:7663-1 [s0; [* Initialization and configuration]] 201:: [s0;%- ] 202:: [s0; Reset] 203:: [s0; clears column `& index definition and restores all ArrayCtrl 204default properties] 205:: [s0; IsEdit] 206:: [s0; true `= array state automaton is currently in row editing mode] 207:: [s0; IsInsert] 208:: [s0; true `= array state automaton is currently in row insertion 209mode] 210:: [s0; SetLineCy] 211:: [s0; sets array row height (global or individual for a single row)] 212:: [s0; GetLineCy] 213:: [s0; returns logical array row height (value set by preceding SetLineCy)] 214:: [s0; GetLineY] 215:: [s0; returns [/ y] position of given row (relative to table beginning)] 216:: [s0; `[No`]AppendLine] 217:: [s0; `[do not`] display an additional pseudo`-row used for row insertion] 218:: [s0; IsAppendLine] 219:: [s0; returns actual value of the [* AppendLine] property] 220:: [s0; ShowAppendLine] 221:: [s0; scrolls the table view to display the appending line] 222:: [s0; `[No`]Inserting] 223:: [s0; `[do not`] allow inserting new rows] 224:: [s0; IsInserting] 225:: [s0; returns actual value of the [* Inserting] property] 226:: [s0; BeforeAfterInserting] 227:: [s0; allow inserting rows before / after current row (default `= 228before)] 229:: [s0; AfterBeforeInserting] 230:: [s0; allow inserting rows before / after current row (default `= 231after)] 232:: [s0; NoInsertAppend] 233:: [s0; do not autoinsert another row after committing last row insertion] 234:: [s0; IsEditing] 235:: [s0; true `= (at least one column of the) ArrayCtrl supports editing] 236:: [s0; `[No`]Duplicating] 237:: [s0; `[do not`] allow row duplication] 238:: [s0; IsDuplicating] 239:: [s0; returns actual value of the [* Duplicating] property] 240:: [s0; Appending] 241:: [s0; allow appending new row at the table end] 242:: [s0; IsAppending] 243:: [s0; returns actual state of the [* Appending] property] 244:: [s0; AutoAppending] 245:: [s0; allow appending new row at the table end, Enter appends another 246one] 247:: [s0; IsAutoAppending] 248:: [s0; returns actual state of [* AutoAppending] property] 249:: [s0; `[No`]Removing] 250:: [s0; `[do not`] allow table row removing] 251:: [s0; IsRemoving] 252:: [s0; returns actual state of the [* Removing] property] 253:: [s0; `[No`]AskRemove] 254:: [s0; `[do not`] prompt user to confirm row removal] 255:: [s0; IsAskRemove] 256:: [s0; returns actual state of the [* AskRemove] property] 257:: [s0; Moving] 258:: [s0; allow row swapping (moving a row before / after neighbouring 259row)] 260:: [s0; IsMoving] 261:: [s0; returns actual state of the [* Moving] property] 262:: [s0; `[No`]Header] 263:: [s0; `[do not`] display table header] 264:: [s0; `[No`]Track] 265:: [s0; `[do not`] animate tracking table column widths] 266:: [s0; `[No`]VertGrid] 267:: [s0; `[do not`] display column breaks] 268:: [s0; `[No`]HorzGrid] 269:: [s0; `[do not`] display row breaks] 270:: [s0; `[No`]Grid] 271:: [s0; `[do not`] display both grids (VertGrid `+ HorzGrid)] 272:: [s0; GridColor] 273:: [s0; set grid line color] 274:: [s0; EvenRowColor] 275:: [s0; background color for even rows] 276:: [s0; OddRowColor] 277:: [s0; background color for odd rows] 278:: [s0; RowFormat] 279:: [s0; formats menu items substituting given word for the term `'row`'] 280:: [s0; RowName] 281:: [s0; sets the context`-relevant word to substitute for `'row`' in 282the local menu texts] 283:: [s0; NoCursor] 284:: [s0; do not highlight cursor row] 285:: [s0; `[No`]MouseMoveCursor] 286:: [s0; automatically move cursor as the mouse moves (used e.g. in PopupTable)] 287:: [s0; `[No`]AutoHideSb] 288:: [s0; `[do not`] display scroll bar only when necessary] 289:: [s0; MultiSelect] 290:: [s0; enable selecting multiple rows at the same time] 291:: [s0; ColumnWidths] 292:: [s0; sets logical column widths using a formatted string, e.g. `"1 2935 10 10 5 1`"]}}&] 294[s0; &] 295[ {{2337:7663-1 [s0; [* Array index `& column structure management]] 296:: [s0;%- ] 297:: [s0; IndexInfo] 298:: [s0; returns the [* IdInfo] structure describing an index (see below)] 299:: [s0; AddIndex] 300:: [s0; adds a new index to the source data matrix] 301:: [s0; GetIndexCount] 302:: [s0; returns number of index columns (columns in the source data 303matrix)] 304:: [s0; GetId] 305:: [s0; returns identifier of a given index (given by its integral index)] 306:: [s0; GetPos] 307:: [s0; returns integral index of source matrix column ([/ index]) identified 308by an [* Id]] 309:: [s0; SetId] 310:: [s0; sets the [* Id] identifier for a given index (column of the source 311matrix)] 312:: [s0; AddKey] 313:: [s0; sets up the first index to act as primary key (often used for 314SQL tables)] 315:: [s0; GetKeyId] 316:: [s0; returns primary key identifier (equal to [* GetId(0)])] 317:: [s0; AddColumn] 318:: [s0; adds a column`-index pair to the table (one data column, one 319output column)] 320:: [s0; AddColumnAt] 321:: [s0; adds a column bound to a given index] 322:: [s0; AddRowNumColumn] 323:: [s0; adds a column without an index (used for external data)] 324:: [s0; GetColumnCount] 325:: [s0; returns number of (visual) columns in the table] 326:: [s0; FindColumnWithPos] 327:: [s0; locates table column according to given index number] 328:: [s0; FindColumnWithId] 329:: [s0; locates table column according to index identifier] 330:: [s0; ColumnAt] 331:: [s0; returns the [* ArrayCtrl`::Column] structure describing given column] 332:: [s0; HeaderTab] 333:: [s0; returns the [* HeaderCtrl`::Column] structure for the given column] 334:: [s0; HeaderObject] 335:: [s0; returns a reference to the [* HeaderCtrl] object for this table] 336:: [s0; SerializeHeader] 337:: [s0; serialize header layout information (column widths etc.)] 338:: [s0; AddCtrl] 339:: [s0; adds an outer control`-index pair to the table (one data column, 340one outer Ctrl)] 341:: [s0; AddCtrlAt] 342:: [s0; adds an outer control bound to a given index] 343:: [s0; AddRowNumCtrl] 344:: [s0; adds an outer control without an index `- used ([/ seldom]) for 345external data] 346:: [s0; SetDisplay] 347:: [s0; sets display for a given table column or cell] 348:: [s0; GetDisplay] 349:: [s0; returns column / cell display] 350:: [s0; SetCtrl] 351:: [s0; sets a [* Ctrl] object for custom editing of a given cell] 352:: [s0; GetTotalCy] 353:: [s0; returns total row height] 354:: [s0; GetLineAt] 355:: [s0; locate table row when given an [/ y] position (relative to table 356top)] 357:: [s0; GetClickColumn] 358:: [s0; returns column number of last clicked column (Null if clicked 359outside existing rows)] 360:: [s0; GetClickRow] 361:: [s0; returns row number of last clicked row (Null if clicked outside 362existing rows)] 363:: [s0; GetClickPos] 364:: [s0; returns Point(GetClickColumn(), GetClickRow())]}}&] 365[s0; &] 366[ {{2337:7663-1 [s0; [* Data setting `& retrieval]] 367:: [s0;%- ] 368:: [s0; SetCount] 369:: [s0; sets number of rows in the array] 370:: [s0; SetVirtualCount] 371:: [s0; sets number of rows in the array with external data] 372:: [s0; GetCount] 373:: [s0; returns number of rows] 374:: [s0; Clear] 375:: [s0; clears array data, identical to [* SetCount(0)]] 376:: [s0; Shrink] 377:: [s0; shrinks source data matrix to the minimum necessary size] 378:: [s0; Get] 379:: [s0; returns given Value element of the source data matrix] 380:: [s0; GetOriginal] 381:: [s0; returns given element of source data matrix before editing] 382:: [s0; Set] 383:: [s0; sets given element of the source data matrix] 384:: [s0; GetKey] 385:: [s0; returns given primary key (column #0 in the data matrix)] 386:: [s0; GetOriginalKey] 387:: [s0; returns `'old`' value of primary key before editing] 388:: [s0; GetColumn] 389:: [s0; returns value of a given output column (according to its index 390mapping)] 391:: [s0; GetConvertedColumn] 392:: [s0; returns value of a given output column after applying its [* Convert]] 393:: [s0; ReadRow] 394:: [s0; returns a row of the source data matrix] 395:: [s0; Add] 396:: [s0; adds a new row at the end of table] 397:: [s0; Insert] 398:: [s0; inserts a new row into the table] 399:: [s0; Remove] 400:: [s0; removes a given table row] 401:: [s0; SwapUp] 402:: [s0; exchanges a table row with the preceding row] 403:: [s0; SwapDown] 404:: [s0; exchanges a table row with the next row] 405:: [s0; Sort] 406:: [s0; sorts table rows using a given predicate] 407:: [s0; ClearCache] 408:: [s0; clears data conversion cache] 409:: [s0; InvalidateCache] 410:: [s0; invalidates given table row in the conversion cache]}}&] 411[s0; &] 412[ {{2337:7663-1 [s0; [* Cursor `& selection management]] 413:: [s0;%- ] 414:: [s0; GetSelectCount] 415:: [s0; returns number of currently selected rows] 416:: [s0; IsSelection] 417:: [s0; checks whether any rows are selected (identical to [* GetSelectCount() 418> 0])] 419:: [s0; Select] 420:: [s0; selects / unselects given row or a series of rows] 421:: [s0; IsSelected] 422:: [s0; checks whether given row is selected] 423:: [s0; ClearSelection] 424:: [s0; clears the current selection] 425:: [s0; SetCursor] 426:: [s0; moves array cursor to a new row] 427:: [s0; KillCursor] 428:: [s0; removes the cursor away from the table] 429:: [s0; CancelCursor] 430:: [s0; cancels editing of current row] 431:: [s0; IsCursor] 432:: [s0; checks whether cursor is in the table (identical to [* GetCursor() 433>`= 0])] 434:: [s0; GetCursor] 435:: [s0; returns current cursor row, `-1 when none] 436:: [s0; GoBegin] 437:: [s0; moves the cursor to the first table row] 438:: [s0; GoEnd] 439:: [s0; moves the cursor to the last table row] 440:: [s0; GetCursorSc] 441:: [s0; returns the location of the cursor row within the table view 442area] 443:: [s0; ScCursor] 444:: [s0; scrolls the table to move the cursor row to given location within 445the table view] 446:: [s0; CenterCursor] 447:: [s0; scrolls the table to move cursor into the middle of the current 448view] 449:: [s0; ScrollInto] 450:: [s0; scrolls the table by minimum amount necessary to make given 451row visible] 452:: [s0; ScrollIntoCursor] 453:: [s0; scrolls the table by minimum amount necessary to make cursor 454row visible] 455:: [s0; GetScroll] 456:: [s0; returns current table scrollbar location] 457:: [s0; ScrollTo] 458:: [s0; sets table scrollbar location] 459:: [s0; Find] 460:: [s0; locates table row containing a given element] 461:: [s0; FindSetCursor] 462:: [s0; moves the cursor to table row containing a given element]}}&] 463[s0;3 &] 464[s0; &] 465[s0; &] 466[ {{2337:7663-1 [s0; [* GUI elements]] 467:: [s0;%- ] 468:: [s0; StdBar] 469:: [s0; the default array local menu] 470:: [s0; IsModified] 471:: [s0; checks modification state of given array cell] 472:: [s0; StartEdit] 473:: [s0; open current array row for editing] 474:: [s0; GetEditColumn] 475:: [s0; returns the column being currently edited] 476:: [s0; DoEdit] 477:: [s0; corresponds to the local menu `'Edit`' function] 478:: [s0; DoInsert] 479:: [s0; corresponds to the local menu `'Insert`' function] 480:: [s0; DoInsertBefore] 481:: [s0; corresponds to the local menu `'Insert before`' function] 482:: [s0; DoInsertAfter] 483:: [s0; corresponds to the local menu `'Insert after`' function] 484:: [s0; DoAppend] 485:: [s0; corresponds to the local menu `'Append`' function] 486:: [s0; DoRemove] 487:: [s0; corresponds to the local menu `'Remove`' function] 488:: [s0; DoDuplicate] 489:: [s0; corresponds to the local menu `'Duplicate`' function] 490:: [s0; DoSelectAll] 491:: [s0; selects the entire array] 492:: [s0; AcceptEnter] 493:: [s0; commits the currently edited row and possibly begins insertion 494of another row]}}&] 495[s0; &] 496[ {{2337:7663-1 [s0; [* Notification callbacks]] 497:: [s0;%- ] 498:: [s0; WhenLeftClick] 499:: [s0; left mouse click within the array] 500:: [s0; WhenLeftDouble] 501:: [s0; left mouse doubleclick within the array] 502:: [s0; WhenSel] 503:: [s0; called when cursor or selection status of widget changes] 504:: [s0; WhenCursor] 505:: [s0; called whenever the cursor location changes [/ (deprecated, use 506WhenSel)]] 507:: [s0; WhenKillCursor] 508:: [s0; called when the cursor moves away from the table [/ (deprecated, 509use WhenSel)]] 510:: [s0; WhenSelection] 511:: [s0; called whenever current selection changes [/ (deprecated, use 512WhenSel)]] 513:: [s0; WhenEnterRow] 514:: [s0; called whenever the cursor moves to a new row [/ (deprecated, 515use WhenSel)]] 516:: [s0; WhenUpdateRow] 517:: [s0; called after updating a row] 518:: [s0; WhenAcceptRow] 519:: [s0; additional row validation callback] 520:: [s0; WhenStartEdit] 521:: [s0; called after initiating row editing] 522:: [s0; WhenAcceptEdit] 523:: [s0; called after accepting changes to a given row] 524:: [s0; WhenArrayAction] 525:: [s0; called whenever array source data changes (after insert / delete 526/ edit)] 527:: [s0; WhenBar] 528:: [s0; can be used to supply custom local menu for the array] 529:: [s0; WhenCtrlsAction] 530:: [s0; called by [* WhenAction] callbacks of internally created controls]}}&] 531[s3; &] 532[s0; &] 533[s0; &] 534[s0; &] 535[ {{10000t/25b/25@3 [s0; [*@(229)4 Detailed method description]]}}&] 536[s0; &] 537[s0; [* Initialization and configuration]&] 538[s3; &] 539[s0; &] 540[s5;:ArrayCtrl`:`:Reset`(`): [@(0.0.255) void]_[* Reset]()&] 541[s2; Clears table rows and resets all array properties to their default 542values.&] 543[s3; &] 544[s4; &] 545[s5;:ArrayCtrl`:`:ShowAppendLine`(`): [@(0.0.255) void]_[* ShowAppendLine]()&] 546[s2; Show an additional pseudo`-row at the table end. When clicked, 547a new row is appended to the array.&] 548[s3; &] 549[s4;%- &] 550[s5;:Upp`:`:ArrayCtrl`:`:AcceptRow`(`):%- [@(0.0.255) bool]_[* AcceptRow]()&] 551[s2; When there are slave widgets (connected using AddCtrl), the 552visible content of ArrayCtrl line is normally updated when cursor 553moves to another line (and the move is prevented if any slave 554widget has invalid value). This method tries to check for invalid 555values and updates the row immediately. Returns true if there 556were no invalid values in slave widgets.&] 557[s3;%- &] 558[s4; &] 559[s5;:ArrayCtrl`:`:IsEdit`(`)const: [@(0.0.255) bool]_[* IsEdit]()_[@(0.0.255) const]&] 560[s2; Checks whether the array is currently being edited.&] 561[s7; [*/ Return value]-|[* true] `= a row is currently open for editing, 562[* false] `= array is in normal browsing mode&] 563[s3; &] 564[s4; &] 565[s5;:ArrayCtrl`:`:IsInsert`(`)const: [@(0.0.255) bool]_[* IsInsert]()_[@(0.0.255) const]&] 566[s2; Checks whether a new row is currently being inserted.&] 567[s7; [*/ Return value]-|[* true] `= newly inserted row is currently being 568edited, [* false] when not&] 569[s3; &] 570[s4; &] 571[s5;:ArrayCtrl`:`:SetLineCy`(int`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* SetLineCy]([@(0.0.255) i 572nt]_[*@3 cy])&] 573[s2; Sets the (default) array row height. For certain rows, this 574can be overriden by the two`-parameter version of this method.&] 575[s7; [*C@3 cy]-|row height in pixels&] 576[s3; &] 577[s4; &] 578[s5;:ArrayCtrl`:`:SetLineCy`(int`,int`): [@(0.0.255) void]_[* SetLineCy]([@(0.0.255) int]_[*@3 i 579], [@(0.0.255) int]_[*@3 cy])&] 580[s2; Sets row height for a given row. This overrides the default 581value set by the one`-parameter version of this method.&] 582[s7; [*C@3 i]-|row index (zero based)&] 583[s7; [*C@3 cy]-|row height in pixels, [* Null] `= use default row height&] 584[s3; &] 585[s4; &] 586[s5;:ArrayCtrl`:`:GetLineCy`(`)const: [@(0.0.255) int]_[* GetLineCy]()_[@(0.0.255) const]&] 587[s2; Returns default array row height.&] 588[s7; [*/ Return value]-|row height in pixels&] 589[s3; &] 590[s4; &] 591[s5;:ArrayCtrl`:`:GetLineY`(int`)const: [@(0.0.255) int]_[* GetLineY]([@(0.0.255) int]_[*@3 i 592])_[@(0.0.255) const]&] 593[s2; Returns [/ y] position of given array row (the pixel distance 594between the top of first array row and [/ i]`-th row, i.e. sum 595of heights of all rows above this row).&] 596[s7; [*C@3 i]-|row index (zero based)&] 597[s7; [*/ Return value]-|Vertical position of row top in pixels (relative 598to array beginning)&] 599[s3; &] 600[s4; &] 601[s5;:ArrayCtrl`:`:GetLineCy`(int`)const: [@(0.0.255) int]_[* GetLineCy]([@(0.0.255) int]_[*@3 i 602])_[@(0.0.255) const]&] 603[s2; Returns the height of a given row (either the row`-specific 604row height, or, when Null, the default row height).&] 605[s7; [*C@3 i]-|row index (zero based)&] 606[s7; [*/ Return value]-|row height in pixels&] 607[s3; &] 608[s4; &] 609[s5;:ArrayCtrl`:`:AppendLine`(bool`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* AppendLine 610]([@(0.0.255) bool]_[*@3 b]_`=_[@(0.0.255) true])&] 611[s2; The AppendLine property controls whether the array displays 612an additional `'append`' row after its last (real) row. &] 613[s7; [*C@3 b]-|[* true] `= display appending row, [* false] `= hide it&] 614[s7; [*/ Return value]-|[* `*this]&] 615[s3; &] 616[s4; &] 617[s5;:ArrayCtrl`:`:NoAppendLine`(`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* NoAppendLine 618]()&] 619[s2; Hide the appending line (identical to [* AppendLine(false)]).&] 620[s7; [*/ Return value]-|[* `*this]&] 621[s3; &] 622[s4; &] 623[s5;:ArrayCtrl`:`:IsAppendLine`(`)const: [@(0.0.255) bool]_[* IsAppendLine]()_[@(0.0.255) c 624onst]&] 625[s2; Returns current state of the [* AppendLine] property.&] 626[s7; [*/ Return value]-|[* true] `= display appending pseudo`-row at the 627end of the array&] 628[s3; &] 629[s4; &] 630[s5;:ArrayCtrl`:`:Inserting`(bool`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* Inserting]( 631[@(0.0.255) bool]_[*@3 b]_`=_[@(0.0.255) true])&] 632[s2; Enable / disable inserting new rows in the array (no matter 633which insertion mechanism is selected).&] 634[s7; [*C@3 b]-|[* true] `= enable insertion, [* false] `= disable it&] 635[s7; [*/ Return value]-|[* `*this]&] 636[s3; &] 637[s4; &] 638[s5;:ArrayCtrl`:`:NoInserting`(`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* NoInserting]( 639)&] 640[s2; Disables row insertion (identical to [* Inserting(false)]).&] 641[s7; [*/ Return value]-|[* `*this]&] 642[s3; &] 643[s4; &] 644[s5;:ArrayCtrl`:`:IsInserting`(`)const: [@(0.0.255) bool]_[* IsInserting]()_[@(0.0.255) con 645st]&] 646[s2; Returns current state of the [* Inserting] property.&] 647[s7; [*/ Return value]-|[* true] `= row insertion is enabled, [* false] 648when not&] 649[s3; &] 650[s4; &] 651[s5;:ArrayCtrl`:`:Appending`(bool`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* Appending]( 652[@(0.0.255) bool]_[*@3 b]_`=_[@(0.0.255) true])&] 653[s2; Enable / disable adding new rows at the table end.&] 654[s7; [*C@3 b]-|[* true] `= enable row appending, [* false] `= disable it&] 655[s7; [*/ Return value]-|[* `*this]&] 656[s3; &] 657[s4; &] 658[s5;:ArrayCtrl`:`:IsAppending`(`)const: [@(0.0.255) bool]_[* IsAppending]()_[@(0.0.255) con 659st]&] 660[s2; Returns current state of the [* Appending] property.&] 661[s7; [*/ Return value]-|[* true] `= appending rows is enabled, [* false] 662when not.&] 663[s3; &] 664[s4; &] 665[s5;:ArrayCtrl`:`:AutoAppending`(bool`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* AutoApp 666ending]([@(0.0.255) bool]_[*@3 b]_`=_[@(0.0.255) true])&] 667[s2; Same as [* Appending] but Enter pressed when editing a new row 668accepts it and adds another one at the table end.&] 669[s7; [*C@3 b]-|[* true ]to enable the mode&] 670[s7; [*/ Return value]-|[* `*this]&] 671[s3; &] 672[s4; &] 673[s5;:ArrayCtrl`:`:IsAutoAppending`(`)const: [@(0.0.255) bool]_[* IsAutoAppending]()_[@(0.0.255) c 674onst]&] 675[s2; Returns current state of [* AutoAppending] property.&] 676[s7; [*/ Return value]-|[* true] `= [* AutoAppending ]is active&] 677[s3; &] 678[s4; &] 679[s5;:ArrayCtrl`:`:BeforeAfterInserting`(int`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* B 680eforeAfterInserting]([@(0.0.255) int]_[*@3 q]_`=_[@3 1])&] 681[s2; Activate before / after row insertion mechanism ([* Insert] hotkey 682`= before).&] 683[s7; [*/ Return value]-|[* `*this]&] 684[s3; &] 685[s4; &] 686[s5;:ArrayCtrl`:`:AfterBeforeInserting`(int`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* A 687fterBeforeInserting]([@(0.0.255) int]_[*@3 q]_`=_[@3 2])&] 688[s2; Activate before / after row insertion mechanism ([* Insert] hotkey 689`= after)&] 690[s7; [*/ Return value]-|[* `*this]&] 691[s3; &] 692[s4; &] 693[s5;:ArrayCtrl`:`:Duplicating`(bool`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* Duplicati 694ng]([@(0.0.255) bool]_[*@3 b]_`=_[@(0.0.255) true])&] 695[s2; Enable / disable row duplication. Note that this property only 696controls whether the `'Duplicate`' item should be present in 697the array local menu. Of course, nothing can prevent you from 698supporting duplication in some other way, or from calling the 699[* DoDuplicate] method as you see fit.&] 700[s7; [*C@3 b]-|[* true] `= enable duplication, [* false] `= disable it&] 701[s7; [*/ Return value]-|[* `*this]&] 702[s3; &] 703[s4; &] 704[s5;:ArrayCtrl`:`:NoDuplicating`(`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* NoDuplicati 705ng]()&] 706[s2; Disable row duplication (identical to [* Duplicating(false)]).&] 707[s7; [*/ Return value]-|[* `*this]&] 708[s3; &] 709[s4; &] 710[s5;:ArrayCtrl`:`:IsDuplicating`(`)const: [@(0.0.255) bool]_[* IsDuplicating]()_[@(0.0.255) c 711onst]&] 712[s2; Returns the state of the [* Duplicating] property.&] 713[s7; [*/ Return value]-|[* true] `= local menu offers row duplication, 714[* false] when not&] 715[s3; &] 716[s4; &] 717[s5;:ArrayCtrl`:`:NoInsertAppend`(bool`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* NoInse 718rtAppend]([@(0.0.255) bool]_[*@3 b]_`=_[@(0.0.255) true])&] 719[s2; Enables / disables the auto`-append mechanism (see above section 720on inserting rows).&] 721[s7; [*C@3 b]-|[* true] `= disable InsertAppend mechanism, [* false] `= 722enable it (the default)&] 723[s7; [*/ Return value]-|[* `*this]&] 724[s3; &] 725[s4; &] 726[s5;:ArrayCtrl`:`:IsEditing`(`)const: [@(0.0.255) bool]_[* IsEditing]()_[@(0.0.255) const]&] 727[s2; Checks whether at least one array column supports editing (whether 728it is possible to [/ open] a row for editing).&] 729[s7; [*/ Return value]-|[* true] `= row editing is possible, [* false] when 730not&] 731[s3; &] 732[s4; &] 733[s5;:ArrayCtrl`:`:Removing`(bool`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* Removing]([@(0.0.255) b 734ool]_[*@3 b]_`=_[@(0.0.255) true])&] 735[s2; Enable / disable deleting rows from the table.&] 736[s7; [*C@3 b]-|[* true] `= enable deletion, [* false] `= disable it&] 737[s7; [*/ Return value]-|[* `*this]&] 738[s3; &] 739[s4; &] 740[s5;:ArrayCtrl`:`:NoRemoving`(`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* NoRemoving]()&] 741[s2; Disable deleting table rows (identical to [* Removing(false)]).&] 742[s7; [*/ Return value]-|[* `*this]&] 743[s3; &] 744[s4; &] 745[s5;:ArrayCtrl`:`:IsRemoving`(`)const: [@(0.0.255) bool]_[* IsRemoving]()_[@(0.0.255) const 746]&] 747[s2; Returns current state of the [* Removing] property.&] 748[s7; [*/ Return value]-|[* true] `= row deletion is enabled, [* false ]when 749not&] 750[s3; &] 751[s4; &] 752[s5;:ArrayCtrl`:`:AskRemove`(bool`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* AskRemove]( 753[@(0.0.255) bool]_[*@3 b]_`=_[@(0.0.255) true])&] 754[s2; Sets whether the user must manually confirm array row deletion. 755When set to [* true], every time a row is to be deleted, a confirmation 756dialog pops up. When set to [* false], rows are deleted automatically 757without any further confirmation.&] 758[s7; [*C@3 b]-|[* true] `= prompt user to confirm row deletion, [* false] 759`= delete rows instantly&] 760[s7; [*/ Return value]-|[* `*this]&] 761[s3; &] 762[s4; &] 763[s5;:ArrayCtrl`:`:NoAskRemove`(`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* NoAskRemove]( 764)&] 765[s2; Disables user confirmation of row deletion (equivalent to [* AskRemove(false)]).&] 766[s7; [*/ Return value]-|[* `*this]&] 767[s3; &] 768[s4; &] 769[s5;:ArrayCtrl`:`:IsAskRemove`(`)const: [@(0.0.255) bool]_[* IsAskRemove]()_[@(0.0.255) con 770st]&] 771[s2; Returns current state of the [* AskRemove] property.&] 772[s7; [*/ Return value]-|[* true] `= user confirmation is needed to delete 773rows, [* false] `= rows are deleted immediately&] 774[s3; &] 775[s4; &] 776[s5;:ArrayCtrl`:`:Moving`(bool`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* Moving]([@(0.0.255) b 777ool]_[*@3 b]_`=_[@(0.0.255) true])&] 778[s2; Enable / disable row swapping. When set to [* true], it is possible 779to move an array row up and down by swapping it with the previous 780/ next row. This can be used to reorder array rows in a visually 781straightforward manner.&] 782[s7; [*C@3 b]-|[* true] `= offer row moving in the local menu, [* false] 783`= don`'t&] 784[s7; [*/ Return value]-|[* `*this]&] 785[s3; &] 786[s4; &] 787[s5;:ArrayCtrl`:`:IsMoving`(`)const: [@(0.0.255) bool]_[* IsMoving]()_[@(0.0.255) const]&] 788[s2; Returns current state of the [* Moving] property.&] 789[s7; [*/ Return value]-|[* true] `= local menu supports row swapping, 790[* false] `= it doesn`'t&] 791[s3; &] 792[s4; &] 793[s5;:ArrayCtrl`:`:Header`(bool`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* Header]([@(0.0.255) b 794ool]_[*@3 b]_`=_[@(0.0.255) true])&] 795[s2; Show / hide the [*^topic`:`/`/CtrlLib`/src`/HeaderCtrl`$en`-us^ HeaderCtrl] 796object for this table.&] 797[s7; [*C@3 b]-|[* true] `= show table header, [* false] `= hide it&] 798[s7; [*/ Return value]-|[* `*this]&] 799[s3; &] 800[s4; &] 801[s5;:ArrayCtrl`:`:NoHeader`(`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* NoHeader]()&] 802[s2; Hide table header (equivalent to [* Header(false)]).&] 803[s7; [*/ Return value]-|[* `*this]&] 804[s3; &] 805[s4; &] 806[s5;:ArrayCtrl`:`:Track`(bool`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* Track]([@(0.0.255) b 807ool]_[*@3 b]_`=_[@(0.0.255) true])&] 808[s2; Animate array column resizing. This is equivalent to setting 809the [*^topic`:`/`/CtrlLib`/src`/HeaderCtrl`$en`-us`#`:`:HeaderCtrl`:`:Track`(bool`)^ T 810rack] property in the array HeaderCtrl.&] 811[s7; [*C@3 b]-|[* true] `= repaint the array repeatedly while dragging 812column widths, [* false] `= regenerate everything only after drag 813`& drop is finished.&] 814[s7; [*/ Return value]-|[* `*this]&] 815[s3; &] 816[s4; &] 817[s5;:ArrayCtrl`:`:NoTrack`(`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* NoTrack]()&] 818[s2; Do not animate array column resizing (equivalent to [* Track(false)]).&] 819[s7; [*/ Return value]-|[* `*this]&] 820[s3; &] 821[s4; &] 822[s5;:ArrayCtrl`:`:VertGrid`(bool`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* VertGrid]([@(0.0.255) b 823ool]_[*@3 b]_`=_[@(0.0.255) true])&] 824[s2; Show / hide vertical array grid lines (separating array columns).&] 825[s7; [*C@3 b]-|[* true] `= show vertical grid lines, [* false] `= hide them&] 826[s7; [*/ Return value]-|[* `*this]&] 827[s3; &] 828[s4; &] 829[s5;:ArrayCtrl`:`:NoVertGrid`(`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* NoVertGrid]()&] 830[s2; Hide vertical grid lines (equivalent to [* VertGrid(false)]).&] 831[s7; [*/ Return value]-|[* `*this]&] 832[s3; &] 833[s4; &] 834[s5;:ArrayCtrl`:`:HorzGrid`(bool`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* HorzGrid]([@(0.0.255) b 835ool]_[*@3 b]_`=_[@(0.0.255) true])&] 836[s2; Show / hide horizontal grid lines (separating array rows).&] 837[s7; [*C@3 b]-|[* true] `= show horizontal grid lines, [* false] `= hide 838them&] 839[s7; [*/ Return value]-|[* `*this]&] 840[s3; &] 841[s4; &] 842[s5;:ArrayCtrl`:`:NoHorzGrid`(`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* NoHorzGrid]()&] 843[s2; Hide horizontal grid lines (equivalent to [* HorzGrid(false)]).&] 844[s7; [*/ Return value]-|[* `*this]&] 845[s3; &] 846[s4; &] 847[s5;:ArrayCtrl`:`:Grid`(bool`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* Grid]([@(0.0.255) b 848ool]_[*@3 b]_`=_[@(0.0.255) true])&] 849[s2; Show / hide both horizontal and vertical grid lines (equivalent 850to [* HorzGrid(b).VertGrid(b)]).&] 851[s7; [*C@3 b]-|[* true] `= show grid line matrix, [* false] `= hide all 852grid lines&] 853[s7; [*/ Return value]-|[* `*this]&] 854[s3; &] 855[s4; &] 856[s5;:ArrayCtrl`:`:NoGrid`(`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* NoGrid]()&] 857[s2; Hide horizontal and vertical grid lines (equivalent to [* Grid(false)]).&] 858[s7; [*/ Return value]-|[* `*this]&] 859[s3; &] 860[s4; &] 861[s5;:ArrayCtrl`:`:GridColor`(Color`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* GridColor]( 862[_^Color^ Color]_[*@3 c])&] 863[s2; Sets the color for grid lines.&] 864[s7; [*C@3 c]-|new grid line color&] 865[s7; [*/ Return value]-|[* `*this]&] 866[s3; &] 867[s4; &] 868[s5;:ArrayCtrl`:`:EvenRowColor`(Color`,Color`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* E 869venRowColor]([_^Color^ Color]_[*@3 paper]_`=_Blend(SColorMark, SColorPaper, 870[@3 220]), [_^Color^ Color]_[*@3 ink]_`=_SColorText)&] 871[s2; Sets the paper and ink (background and foreground) color for 872even array rows. In certain cases setting a different background 873color for odd and even rows helps to simplify visual orientation 874in the arrays (especially when the array has many columns).&] 875[s2; [* Note:] the even / odd row terminology refers to the natural 876array row numbering, so first array row is [/ odd] and the second 877is [/ even]. This is in contrast to the zero`-baesd integral row 878indexing, where the first array row has index 0.&] 879[s7; [*C@3 paper]-|background color to use for second, fourth, sixth 880etc. array row&] 881[s7; [*C@3 ink]-|foreground color for even rows&] 882[s7; [*/ Return value]-|[* `*this]&] 883[s3; &] 884[s4; &] 885[s5;:ArrayCtrl`:`:OddRowColor`(Color`,Color`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* O 886ddRowColor]([_^Color^ Color]_[*@3 paper]_`=_SColorInfo, [_^Color^ Color]_[*@3 ink]_`=_SCo 887lorText)&] 888[s2; Sets the paper and ink (background and foreground) color for 889odd array rows.&] 890[s7; [*C@3 paper]-|background color to use for first, third, fifth etc. 891array row&] 892[s7; [*C@3 ink]-|foreground color for odd rows&] 893[s7; [*/ Return value]-|[* `*this]&] 894[s3; &] 895[s4; &] 896[s5;:ArrayCtrl`:`:NoCursor`(bool`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* NoCursor]([@(0.0.255) b 897ool]_[*@3 b]_`=_[@(0.0.255) true])&] 898[s2; Turns on / off highlighting cursor row.&] 899[s7; [*C@3 b]-|[* true] `= do not highlight cursor row, [* false] `= default 900behaviour (cursor row is shown in inverse colors)&] 901[s7; [*/ Return value]-|[* `*this]&] 902[s3; &] 903[s4; &] 904[s5;:ArrayCtrl`:`:MouseMoveCursor`(bool`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* Mouse 905MoveCursor]([@(0.0.255) bool]_[*@3 b]_`=_[@(0.0.255) true])&] 906[s2; Enables / disables automatical cursor row switching as the mouse 907cursor moves over the array rows.&] 908[s7; [*C@3 b]-|[* true] `= automatically switch cursor row, [* false] `= 909only upon clicks and keyboard navigation&] 910[s7; [*/ Return value]-|[* `*this]&] 911[s3; &] 912[s4; &] 913[s5;:ArrayCtrl`:`:NoMouseMoveCursor`(`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* NoMouse 914MoveCursor]()&] 915[s2; Disable automatical cursor row switching (equivalent to [* MouseMoveCursor(false)]) 916.&] 917[s7; [*/ Return value]-|[* `*this]&] 918[s3; &] 919[s4; &] 920[s5;:ArrayCtrl`:`:AutoHideSb`(bool`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* AutoHideSb 921]([@(0.0.255) bool]_[*@3 b]_`=_[@(0.0.255) true])&] 922[s2; When set to [* true], the vertical scrollbar at the right array 923edge is displayed only when the total row height exceeds the 924array view height. When set to [* false], the scrollbar is shown 925all the time.&] 926[s7; [*C@3 b]-|[* true] `= show / hide the scrollbar as necessary, [* false] 927`= display it unconditionally&] 928[s7; [*/ Return value]-|[* `*this]&] 929[s3; &] 930[s4; &] 931[s5;:ArrayCtrl`:`:NoAutoHideSb`(`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* NoAutoHideSb 932]()&] 933[s2; Display vertical scrollbar all the time (equivalent to [* AutoHideSb(false)]).&] 934[s7; [*/ Return value]-|[* `*this]&] 935[s3; &] 936[s4; &] 937[s5;:ArrayCtrl`:`:HideSb`(bool`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* HideSb]([@(0.0.255) b 938ool]_[*@3 b]_`=_[@(0.0.255) true])&] 939[s2; Hides vertical scrollbar (even if it would be needed).&] 940[s3; &] 941[s4; &] 942[s5;:ArrayCtrl`:`:AutoHideHorzSb`(bool`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* AutoHi 943deHorzSb]([@(0.0.255) bool]_[*@3 b]_`=_[@(0.0.255) true])&] 944[s2; Makes horizontal scroll bar (active if HeaderCtrl is in absolute 945mode only) to autohide. Default is on.&] 946[s3; &] 947[s4; &] 948[s5;:ArrayCtrl`:`:NoAutoHideHorzSb`(`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* NoAutoHi 949deHorzSb]()&] 950[s2; Same as AutoHideHorzSb(false).&] 951[s3; &] 952[s4; &] 953[s5;:ArrayCtrl`:`:HideHorzSb`(bool`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* HideHorzSb 954]([@(0.0.255) bool]_[*@3 b]_`=_[@(0.0.255) true])&] 955[s2; Unconditionally hides horizontal scrollbar (active if HeaderCtrl 956is in absolute mode only).&] 957[s3; &] 958[s4; &] 959[s5;:ArrayCtrl`:`:MultiSelect`(bool`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* MultiSele 960ct]([@(0.0.255) bool]_[*@3 b]_`=_[@(0.0.255) true])&] 961[s2; Enable / disable multiple row selection. &] 962[s7; [*C@3 b]-|[* true] `= allow selecting multiple rows at the same time, 963[* false] `= only one row at a time&] 964[s7; [*/ Return value]-|[* `*this]&] 965[s3; &] 966[s4; &] 967[s5;:ArrayCtrl`:`:IsMultiSelect`(`)const: [@(0.0.255) bool]_[* IsMultiSelect]()_[@(0.0.255) c 968onst]&] 969[s2; Returns true if ArrayCtrl is in multiselect mode.&] 970[s3; &] 971[s4; &] 972[s5;:ArrayCtrl`:`:NoBackground`(bool`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* NoBackgr 973ound]([@(0.0.255) bool]_[*@3 b]_`=_[@(0.0.255) true])&] 974[s2; Sets the widget into transparent mode `- background is not painted 975and Transparent is activated `- a result, anything painted behind 976the widget is visible, allowing client code to provide any background 977it needs.&] 978[s3; &] 979[s4; &] 980[s5;:ArrayCtrl`:`:PopUpEx`(bool`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* PopUpEx]([@(0.0.255) b 981ool]_[*@3 b]_`=_[@(0.0.255) true])&] 982[s2; Activates showing small popup windows with cell content when 983mouse is over and cell is to big to fit current dimensions. Default 984is activated.&] 985[s3; &] 986[s4; &] 987[s5;:ArrayCtrl`:`:NoPopUpEx`(`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* NoPopUpEx]()&] 988[s2; Same as PopUpEx(false).&] 989[s3; &] 990[s4; &] 991[s5;:ArrayCtrl`:`:NoFocusSetCursor`(`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* NoFocusS 992etCursor]()&] 993[s2; Normally, when ArrayCtrl gets a focus and no cursor is set (and 994cursor is allowed and there is at least one line), ArrayCtrl 995a sets the cursor to the first line. This modifier deactivates 996this feature.&] 997[s3; &] 998[s4; &] 999[s5;:ArrayCtrl`:`:MovingHeader`(bool`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* MovingHe 1000ader]([@(0.0.255) bool]_[*@3 b])&] 1001[s2; Activates dragging columns in header. Default is active.&] 1002[s3; &] 1003[s4; &] 1004[s5;:ArrayCtrl`:`:NoMovingHeader`(`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* NoMovingHe 1005ader]()&] 1006[s2; Same as MovingHeader(false).&] 1007[s3; &] 1008[s4; &] 1009[s5;:ArrayCtrl`:`:ColumnSortFindKey`(bool`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* Col 1010umnSortFindKey]([@(0.0.255) bool]_[*@3 b]_`=_[@(0.0.255) true])&] 1011[s2; Before ColumnSort orders the ArrayCtrl, the key of current row 1012(with cursor) is stored and after sorting, it is restored.&] 1013[s3; &] 1014[s4; &] 1015[s5;:ArrayCtrl`:`:AllSorting`(`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* AllSorting]()&] 1016[s2; If set, Sorting() is invoked for all columns (added either before 1017or after this modifier is called).&] 1018[s3; &] 1019[s4; &] 1020[s5;:ArrayCtrl`:`:ColumnSortSecondary`(const ArrayCtrl`:`:Order`&`): [_^ArrayCtrl^ Arra 1021yCtrl][@(0.0.255) `&]_[* ColumnSortSecondary]([@(0.0.255) const]_[_^ArrayCtrl`:`:Order^ O 1022rder][@(0.0.255) `&]_[*@3 order])&] 1023[s2; Sets secondary sorting predicate for column sorts (see ColumnSort, 1024Sorting) `- if two cells are equal when performing sort by column, 1025they are ordered by this predicate.&] 1026[s3; &] 1027[s4; &] 1028[s5;:ArrayCtrl`:`:NoColumnSortSecondary`(`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* NoC 1029olumnSortSecondary]()&] 1030[s2; Removes secondary sorting predicate..&] 1031[s3; &] 1032[s4;%- &] 1033[s5;:Upp`:`:ArrayCtrl`:`:SortingFrom`(int`):%- [_^Upp`:`:ArrayCtrl^ ArrayCtrl][@(0.0.255) `& 1034]_[* SortingFrom]([@(0.0.255) int]_[*@3 from])&] 1035[s2; When ArrayCtrl is sorted (without specifying the range of lines), 1036specifies the first column sorted. This allows for easy header 1037or summation line.&] 1038[s3; &] 1039[s4; &] 1040[s5;:ArrayCtrl`:`:ColumnWidths`(const char`*`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* C 1041olumnWidths]([@(0.0.255) const]_[@(0.0.255) char]_`*[*@3 s])&] 1042[s2; Initializes column widths based on a text string containing 1043blank`-separated decimal numbers, e.g. `"1 4 6 4 1`".&] 1044[s7; [*C@3 s]-|control string defining column widths&] 1045[s7; [*/ Return value]-|[* `*this]&] 1046[s3; &] 1047[s4; &] 1048[s5;:ArrayCtrl`:`:GetColumnWidths`(`): [_^String^ String]_[* GetColumnWidths]()&] 1049[s2; Returns current column widths in format compatible with ColumnWidths.&] 1050[s3; &] 1051[s4; &] 1052[s5;:ArrayCtrl`:`:CursorOverride`(const Image`&`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `& 1053]_[* CursorOverride]([@(0.0.255) const]_[_^Image^ Image][@(0.0.255) `&]_[*@3 arrow])&] 1054[s2; Overrides mouse cursor to [*@3 arrow]. Setting Null ends override.&] 1055[s3; &] 1056[s4; &] 1057[s5;:ArrayCtrl`:`:NoCursorOverride`(`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* NoCursor 1058Override]()&] 1059[s2; Same as CursorOverride(Null).&] 1060[s3; &] 1061[s4;%- &] 1062[s5;:Upp`:`:ArrayCtrl`:`:SpanWideCells`(bool`):%- [_^Upp`:`:ArrayCtrl^ ArrayCtrl][@(0.0.255) `& 1063]_[* SpanWideCells]([@(0.0.255) bool]_[*@3 b]_`=_[@(0.0.255) true])&] 1064[s2; In this mode, if cell content (as defined by Display`::GetStdSize) 1065is wider than cell width and next cell is Null (empty), the cell 1066width is extended to span over the next cell (just like in common 1067spreadsheet applications). ArrayCtrl header must no be in Moving 1068mode for correct operation. Returns `*this.&] 1069[s3; &] 1070[s4; &] 1071[s5;:ArrayCtrl`:`:RowFormat`(const char`*`): [_^String^ String]_[* RowFormat]([@(0.0.255) c 1072onst]_[@(0.0.255) char]_`*[*@3 s])&] 1073[s2; Formats a text by substituting [* %s] with the array`-specific 1074term for `'row`' (as set by the [* RowName] property). This is 1075used for array local menu items. Returns `*this.&] 1076[s3; &] 1077[s4; &] 1078[s5;:ArrayCtrl`:`:RowName`(const char`*`): [_^ArrayCtrl^ ArrayCtrl][@(0.0.255) `&]_[* RowNa 1079me]([@(0.0.255) const]_[@(0.0.255) char]_`*[*@3 s])&] 1080[s2; Sets the array`-specific term for `'row`'. This can be used 1081to customize the local menu terminology according to the logical 1082content of the array. For instance, when you have an array with 1083the list of employees, you can call [* RowName(`"employee`")] and 1084the menu items will then read [/ `'Insert new employee`', `'Delete 1085employee`'] etc.&] 1086[s7; [*C@3 s]-|the term to substitute for `'array row`' in menu items&] 1087[s7; [*/ Return value]-|[* `*this]&] 1088[s3; &] 1089[s0;* &] 1090[s0; [* Column structure programming]&] 1091[s3; &] 1092[s0; &] 1093[s5;:ArrayCtrl`:`:IndexInfo`(int`): [_^ArrayCtrl`:`:IdInfo^ IdInfo][@(0.0.255) `&]_[* Index 1094Info]([@(0.0.255) int]_[*@3 ii])&] 1095[s2; Returns a reference to the [* IdInfo] structure describing a given 1096array index (column in the source data matrix).&] 1097[s7; [*C@3 ii]-|zero`-based ordinal number of the array index&] 1098[s7; [*/ Return value]-|IdInfo reference for the given index&] 1099[s3; &] 1100[s4; &] 1101[s5;:ArrayCtrl`:`:IndexInfo`(const Id`&`): [_^ArrayCtrl`:`:IdInfo^ IdInfo][@(0.0.255) `&]_ 1102[* IndexInfo]([@(0.0.255) const ][_^Id^ Id]`&_[*@3 id])&] 1103[s2; Returns a reference to the [* IdInfo] structure describing a given 1104array index.&] 1105[s7; [*C@3 id]-|the [* Id] index identifier&] 1106[s7; [*/ Return value]-|IdInfo reference for the given index&] 1107[s3; &] 1108[s4; &] 1109[s5;:ArrayCtrl`:`:AddIndex`(const Id`&`): [_^ArrayCtrl`:`:IdInfo^ IdInfo][@(0.0.255) `&]_ 1110[* AddIndex]([@(0.0.255) const] [_^Id^ Id]`&_[*@3 id])&] 1111[s2; Adds a new index to the array and assign it a given [* Id] identifier.&] 1112[s7; [*C@3 id]-|new index identifier&] 1113[s7; [*/ Return value]-|A reference to the [* IdInfo ]structure describing 1114the newly added index. The reference can be used to set additional 1115index properties.&] 1116[s3; &] 1117[s4; &] 1118[s5;:ArrayCtrl`:`:AddIndex`(`): [_^ArrayCtrl`:`:IdInfo^ IdInfo][@(0.0.255) `&]_[* AddIndex]( 1119)&] 1120[s2; Adds a new index (without an identifier) to the array.&] 1121[s7; [*/ Return value]-|A reference to the [* IdInfo] structure describing 1122the newly added index.&] 1123[s3; &] 1124[s4; &] 1125[s5;:ArrayCtrl`:`:GetIndexCount`(`)const: [@(0.0.255) int]_[* GetIndexCount]()_[@(0.0.255) c 1126onst]&] 1127[s2; Returns number of indices in the array.&] 1128[s7; [*/ Return value]-|index count&] 1129[s3; &] 1130[s4; &] 1131[s5;:ArrayCtrl`:`:GetId`(int`)const: [_^Id^ Id]_[* GetId]([@(0.0.255) int]_[*@3 ii])_[@(0.0.255) c 1132onst]&] 1133[s2; Returns the identifier of a given index (addresses by its zero`-based 1134ordinal number).&] 1135[s7; [*C@3 ii]-|zero`-based ordinal number of the queried index&] 1136[s7; [*/ Return value]-|index identifier or [* Null] if the index has 1137no identifier&] 1138[s3; &] 1139[s4; &] 1140[s5;:ArrayCtrl`:`:GetPos`(const Id`&`)const: [@(0.0.255) int]_[* GetPos]([@(0.0.255) const 1141][_^Id^ Id]`&_[*@3 id])_[@(0.0.255) const]&] 1142[s2; Returns the zero`-based positional number of the array index 1143with a given identifier.&] 1144[s7; [*C@3 id]-|array index identifier&] 1145[s7; [*/ Return value]-|zero`-based index number, `-1 when not found&] 1146[s3; &] 1147[s4; &] 1148[s5;:ArrayCtrl`:`:SetId`(int`,const Id`&`): [_^ArrayCtrl`:`:IdInfo^ IdInfo][@(0.0.255) `& 1149]_[* SetId]([@(0.0.255) int]_[*@3 ii], [@(0.0.255) const ][_^Id^ Id]`&_[*@3 id])&] 1150[s2; Sets the identifier for a given array index. This can be used 1151to set or modify the identifier for a previously added index.&] 1152[s7; [*C@3 ii]-|zero`-based ordinal number of the index to set the identifier 1153for&] 1154[s7; [*C@3 id]-|new index identifier ([* Null] when none)&] 1155[s7; [*/ Return value]-|A reference to the [* IdInfo] descriptive structure 1156for the [/ ii]`-th index. The reference can be used to set additional 1157properties of the altered index.&] 1158[s3; &] 1159[s4; &] 1160[s5;:ArrayCtrl`:`:AddKey`(const Id`&`): [_^ArrayCtrl`:`:IdInfo^ IdInfo][@(0.0.255) `&]_[* A 1161ddKey]([@(0.0.255) const ][_^Id^ Id]`&_[*@3 id])&] 1162[s2; Adds a [/ primary key] index to the table. The [/ primary key] is 1163just another name for the first index (index with ordinal number 11640). This is just a handy convention often used for SQL`-based 1165tables. [* AddKey] must be called only once after array initialization 1166or [* Reset] and before calling any other functions adding indices 1167(like [* AddIndex], [* AddColumn] or [* AddCtrl]). When [* GetIndexCount() 1168> 0 ]before the call to this function, this method fails with 1169an [* ASSERT].&] 1170[s7; [*C@3 id]-|primary key identifier&] 1171[s7; [*/ Return value]-|A reference to the descriptive [* IdInfo] structure 1172for the primary key index.&] 1173[s3; &] 1174[s4; &] 1175[s5;:ArrayCtrl`:`:AddKey`(`): [_^ArrayCtrl`:`:IdInfo^ IdInfo][@(0.0.255) `&]_[* AddKey]()&] 1176[s2; Adds a primary key index without an identifier to the table. 1177This is equivalent to [* AddKey(Null)].&] 1178[s7; [*/ Return value]-|A reference to the [* IdInfo] structure describing 1179the primary key index.&] 1180[s3; &] 1181[s4; &] 1182[s5;:ArrayCtrl`:`:GetKeyId`(`)const: [_^Id^ Id]_[* GetKeyId]()_[@(0.0.255) const]&] 1183[s2; Returns primary key identifier for this table. This is equivalent 1184to calling [* GetId(0)].&] 1185[s7; [*/ Return value]-|primary key index identifier&] 1186[s3; &] 1187[s4; &] 1188[s5;:ArrayCtrl`:`:AddColumn`(const char`*`,int`): [_^ArrayCtrl`:`:Column^ Column][@(0.0.255) `& 1189]_[* AddColumn]([@(0.0.255) const]_[@(0.0.255) char]_`*[*@3 text]_`=_NULL, 1190[@(0.0.255) int]_[*@3 w]_`=_[@3 0])&] 1191[s2; Add a new column`-index pair to the table. The function adds 1192a (source) index and an (output) column and sets the index as 1193the data source for the column. This is the most common method 1194for adding columns to the array.&] 1195[s7; [*C@3 text]-|column name (displayed in the array header)&] 1196[s7; [*C@3 w]-|logical relative column width&] 1197[s7; [*/ Return value]-|A reference to the [* Column] structure describing 1198the newly added column. This can be used to set additional properties 1199for the newly added column and the corresponding header tab.&] 1200[s3; &] 1201[s4; &] 1202[s5;:ArrayCtrl`:`:AddColumn`(const Id`&`,const char`*`,int`): [_^ArrayCtrl`:`:Column^ C 1203olumn][@(0.0.255) `&]_[* AddColumn]([@(0.0.255) const ][_^Id^ Id]`&_[*@3 id], 1204[@(0.0.255) const]_[@(0.0.255) char]_`*[*@3 text], [@(0.0.255) int]_[*@3 w]_`=_[@3 0])&] 1205[s2; Adds a new column`-index pair to the table. This is equivalent 1206to the above two`-parameter version but, in addition, the method 1207sets the [* Id] identifier for the newly created index.&] 1208[s7; [*C@3 id]-|new index identifier&] 1209[s7; [*C@3 text]-|column name (displayed in the header)&] 1210[s7; [*C@3 w]-|logical relative column width&] 1211[s7; [*/ Return value]-|A reference to the [* Column] structure describing 1212the newly added array column.&] 1213[s3; &] 1214[s4; &] 1215[s5;:ArrayCtrl`:`:AddColumnAt`(int`,const char`*`,int`): [_^ArrayCtrl`:`:Column^ Column 1216][@(0.0.255) `&]_[* AddColumnAt]([@(0.0.255) int]_[*@3 ii], [@(0.0.255) const]_[@(0.0.255) ch 1217ar]_`*[*@3 text], [@(0.0.255) int]_[*@3 w]_`=_[@3 0])&] 1218[s2; Adds a new column to the table and binds it to a given source 1219data index.&] 1220[s7; [*C@3 ii]-|zero`-based ordinal number of the index to use as source 1221for this column&] 1222[s7; [*C@3 text]-|column name (displayed in the header)&] 1223[s7; [*C@3 w]-|logical relative column width&] 1224[s7; [*/ Return value]-|A reference to the [* Column] structure describing 1225the newly added array column.&] 1226[s3; &] 1227[s4; &] 1228[s5;:ArrayCtrl`:`:AddColumnAt`(const Id`&`,const char`*`,int`): [_^ArrayCtrl`:`:Column^ C 1229olumn][@(0.0.255) `&]_[* AddColumnAt]([@(0.0.255) const ][_^Id^ Id]`&_[*@3 id], 1230[@(0.0.255) const]_[@(0.0.255) char]_`*[*@3 text], [@(0.0.255) int]_[*@3 w]_`=_[@3 0])&] 1231[s2; Adds a new column to the table and binds it to a given source 1232data index.&] 1233[s7; [*C@3 id]-|identifier of the index to use as source for the newly 1234added column&] 1235[s7; [*C@3 text]-|column name (displayed in the header)&] 1236[s7; [*C@3 w]-|logical relative column width&] 1237[s7; [*/ Return value]-|A reference to the [* Column] structure describing 1238the newly added array column.&] 1239[s3; &] 1240[s4; &] 1241[s5;:ArrayCtrl`:`:AddRowNumColumn`(const char`*`,int`): [_^ArrayCtrl`:`:Column^ Column][@(0.0.255) `& 1242]_[* AddRowNumColumn]([@(0.0.255) const]_[@(0.0.255) char]_`*[*@3 text], 1243[@(0.0.255) int]_[*@3 w]_`=_[@3 0])&] 1244[s2; Adds a new column to the table. The newly added column has no 1245source index, it is assumed to have an external data source. 1246Instead of the source data [* Value] object, the current zero`-based 1247row number is passed to the column`'s [* Convert] / [* Display]. 1248This allows the host application to decode somehow the external 1249data based on the row number. In the current U`+`+ version, the 1250[/ RowNum columns] cannot be edited (using the standard array inline 1251editing mechanism).&] 1252[s7; [*C@3 text]-|column name (displayed in the header)&] 1253[s7; [*C@3 w]-|logical relative column width&] 1254[s7; [*/ Return value]-|A reference to the [* Column] structure describing 1255the newly added array column.&] 1256[s3; &] 1257[s4; &] 1258[s5;:ArrayCtrl`:`:AddCtrl`(Ctrl`&`): [_^ArrayCtrl`:`:IdInfo^ IdInfo][@(0.0.255) `&]_[* AddC 1259trl]([_^Ctrl^ Ctrl][@(0.0.255) `&]_[*@3 ctrl])&] 1260[s2; Adds a new index`-control pair to the table; the index keeps 1261the source data and the external control is used to edit it. 1262The ArrayCtrl handles data transfer between the source data matrix 1263and the external control. The method returns a reference the 1264[* IdInfo] descriptive structure for the newly added index.&] 1265[s2; [* Note:] it is good to keep in mind that there are a few differences 1266between the ordinary array cell editors and the freestanding 1267edit controls. In contrast with the cell editors, which appear 1268only when the row is opened for editing, the freestanding controls 1269are present all the time. For instance, the ArrayCtrl automatically 1270disables the controls when the cursor moves away from the table 1271(using [* KillCursor]) and re`-enables them after it comes back. 1272This is important e.g. if you want to implement an additional 1273logic enabling some of the controls only depending on the circumstances; 1274in such case, you have to use one of the notification callbacks 1275(like [* WhenEnterRow]) to force your additional behaviour on 1276the controls.&] 1277[s7; [*C@3 ctrl]-|control to attach to the given index&] 1278[s7; [*/ Return value]-|a reference to the IdInfo structure describing 1279the newly added index&] 1280[s3; &] 1281[s4; &] 1282[s5;:ArrayCtrl`:`:AddCtrl`(const Id`&`,Ctrl`&`): [_^ArrayCtrl`:`:IdInfo^ IdInfo][@(0.0.255) `& 1283]_[* AddCtrl]([@(0.0.255) const ][_^Id^ Id]`&_[*@3 id], [_^Ctrl^ Ctrl][@(0.0.255) `&]_[*@3 ctrl 1284])&] 1285[s2; Adds a new index`-control pair to the table. This is identical 1286to the above version with the only difference that the newly 1287added index is assigned an [* Id] identifier at the same time.&] 1288[s7; [*C@3 id]-|the identifier to assign to the newly created index&] 1289[s7; [*C@3 ctrl]-|freestanding control used to edit the given index&] 1290[s7; [*/ Return value]-|a reference to the IdInfo structure describing 1291the newly added index&] 1292[s3; &] 1293[s4; &] 1294[s5;:ArrayCtrl`:`:AddIdCtrl`(Ctrl`&`): [_^ArrayCtrl`:`:IdInfo^ IdInfo][@(0.0.255) `&]_[* Ad 1295dIdCtrl]([_^Ctrl^ Ctrl][@(0.0.255) `&]_[*@3 ctrl])&] 1296[s2; Same as AddCtrl(ctrl.GetLayoutId(), ctrl). Helpful when adding 1297dialog widgets whose id is the same as widget`'s variable id.&] 1298[s3; &] 1299[s4; &] 1300[s5;:ArrayCtrl`:`:AddCtrlAt`(int`,Ctrl`&`): [@(0.0.255) void]_[* AddCtrlAt]([@(0.0.255) int 1301]_[*@3 ii], [_^Ctrl^ Ctrl][@(0.0.255) `&]_[*@3 ctrl])&] 1302[s2; Adds a new control to the table and binds it to the index with 1303given ordinal number. You can use this method to create the binding 1304between the control and an arbitrary source index.&] 1305[s7; [*C@3 ii]-|zero`-based ordinal number of the index to bind to this 1306control&] 1307[s7; [*C@3 ctrl]-|freestanding control used to edit the [/ ii]`-th data 1308index&] 1309[s3; &] 1310[s4; &] 1311[s5;:ArrayCtrl`:`:AddCtrlAt`(const Id`&`,Ctrl`&`): [@(0.0.255) void]_[* AddCtrlAt]([@(0.0.255) c 1312onst ][_^Id^ Id]`&_[*@3 id], [_^Ctrl^ Ctrl][@(0.0.255) `&]_[*@3 ctrl])&] 1313[s2; Adds a new control to the table and binds it to the index with 1314given identifier.&] 1315[s7; [*C@3 id]-|identifier of the index to bind to this control&] 1316[s7; [*C@3 ctrl]-|freestanding control used to edit the index with identifier 1317[/ id]&] 1318[s3; &] 1319[s4; &] 1320[s5;:ArrayCtrl`:`:AddRowNumCtrl`(Ctrl`&`): [@(0.0.255) void]_[* AddRowNumCtrl]([_^Ctrl^ Ctr 1321l][@(0.0.255) `&]_[*@3 ctrl])&] 1322[s2; Adds a new freestanding control to the table. The control is 1323not bound to any source data index. During cursor movement in 1324the array, array uses the control`'s [* SetData] method to set 1325it to the current row number. The control must be ready for that 1326and it can use the row number value to decode some externally 1327located data for display. In the current U`+`+ version, such 1328controls cannot be used for editing (there is currently no clean 1329way to store the edited data back to its external storage).&] 1330[s7; [*C@3 ctrl]-|[/ RowNum]`-based freestanding editor control&] 1331[s3; &] 1332[s4; &] 1333[s5;:ArrayCtrl`:`:GetColumnCount`(`)const: [@(0.0.255) int]_[* GetColumnCount]()_[@(0.0.255) c 1334onst]&] 1335[s2; Returns the current number of (output) columns in the array.&] 1336[s7; [*/ Return value]-|number of columns&] 1337[s3; &] 1338[s4; &] 1339[s5;:ArrayCtrl`:`:FindColumnWithPos`(int`)const: [@(0.0.255) int]_[* FindColumnWithPos]([@(0.0.255) i 1340nt]_[*@3 pos])_[@(0.0.255) const]&] 1341[s2; Returns the zero`-based index of a column based on its source 1342data index.&] 1343[s7; [*C@3 pos]-|ordinal number of the source index&] 1344[s7; [*/ Return value]-|ordinal number of the column having the given 1345index as its source, `-1 when not found&] 1346[s3; &] 1347[s4; &] 1348[s5;:ArrayCtrl`:`:FindColumnWithId`(const Id`&`)const: [@(0.0.255) int]_[* FindColumnWith 1349Id]([@(0.0.255) const ][_^Id^ Id]`&_[*@3 id])_[@(0.0.255) const]&] 1350[s2; Returns the zero`-based index of a column based on its source 1351data index.&] 1352[s7; [*C@3 id]-|source index identifier&] 1353[s7; [*/ Return value]-|ordinal number of the column having the given 1354index as its source, `-1 when not found&] 1355[s3; &] 1356[s4; &] 1357[s5;:ArrayCtrl`:`:ColumnAt`(int`): [_^ArrayCtrl`:`:Column^ Column][@(0.0.255) `&]_[* Column 1358At]([@(0.0.255) int]_[*@3 i])&] 1359[s2; Returns the [* Column] structure describing a given column.&] 1360[s7; [*C@3 i]-|zero`-based column index&] 1361[s7; [*/ Return value]-|a reference to the [* Column] structure describing 1362the given column&] 1363[s3; &] 1364[s4; &] 1365[s5;:ArrayCtrl`:`:ColumnAt`(const Id`&`): [_^ArrayCtrl`:`:Column^ Column][@(0.0.255) `&]_ 1366[* ColumnAt]([@(0.0.255) const ][_^Id^ Id]`&_[*@3 id])&] 1367[s2; Returns the [* Column] structure describing a given column.&] 1368[s7; [*C@3 i]-|zero`-based column index&] 1369[s7; [*/ Return value]-|a constant reference to the [* Column] structure 1370describing the given column&] 1371[s3; &] 1372[s4; &] 1373[s5;:ArrayCtrl`:`:ColumnAt`(int`)const: [@(0.0.255) const]_[_^ArrayCtrl`:`:Column^ Column 1374][@(0.0.255) `&]_[* ColumnAt]([@(0.0.255) int]_[*@3 i])_[@(0.0.255) const]&] 1375[s2; Returns the [* Column] structure describing a column with given 1376source index. This is merely the const version of the above method; 1377it can be used to query properties for the column.&] 1378[s7; [*C@3 id]-|identifier of the index used as source for the column&] 1379[s7; [*/ Return value]-|a reference to the [* Column] structure describing 1380the given column&] 1381[s3; &] 1382[s4; &] 1383[s5;:ArrayCtrl`:`:ColumnAt`(const Id`&`)const: [@(0.0.255) const]_[_^ArrayCtrl`:`:Column^ C 1384olumn][@(0.0.255) `&]_[* ColumnAt]([@(0.0.255) const ][_^Id^ Id]`&_[*@3 id])_[@(0.0.255) cons 1385t]&] 1386[s2; Returns a constant reference to the [* Column] structure describing 1387a column with given source index. This is the constant version 1388of the above method; it can be used to query properties for the 1389column.&] 1390[s7; [*C@3 id]-|identifier of the index used as source for the column&] 1391[s7; [*/ Return value]-|a constant reference to the [* Column] structure 1392describing the given column&] 1393[s3; &] 1394[s4; &] 1395[s5;:ArrayCtrl`:`:HeaderTab`(int`): [_^HeaderCtrl`:`:Column^ HeaderCtrl`::Column][@(0.0.255) `& 1396]_[* HeaderTab]([@(0.0.255) int]_[*@3 i])&] 1397[s2; Returns the [*^topic`:`/`/CtrlLib`/src`/HeaderCtrl`$en`-us`#`:`:HeaderCtrl`:`:Column`:`:Min`(int`)^ H 1398eaderCtrl`::Column] descriptive structure for the given column. 1399The correspondence between the array columns and the header tabs 1400is 1:1, so that the indices of both are always the same ([* array.GetColumnCount() 1401`=`= array.HeaderObject().GetCount()] holds all the time).&] 1402[s7; [*C@3 i]-|zero`-based column index&] 1403[s7; [*/ Return value]-|a reference to the [* HeaderCtrl`::Column] structure. 1404This can be used to set additional properties of the header column 1405(e.g. column width constraints, font and icon for the column 1406title etc.)&] 1407[s3; &] 1408[s4; &] 1409[s5;:ArrayCtrl`:`:HeaderTab`(int`)const: [@(0.0.255) const]_[_^HeaderCtrl`:`:Column^ Head 1410erCtrl`::Column][@(0.0.255) `&]_[* HeaderTab]([@(0.0.255) int]_[*@3 i])_[@(0.0.255) const]&] 1411[s2; Returns a constant reference to the [* HeaderCtrl`::Column] structure 1412for the given column.&] 1413[s7; [*C@3 i]-|zero`-based column index&] 1414[s7; [*/ Return value]-|a reference to the [* HeaderCtrl`::Column] structure. 1415This can be used to set additional properties of the header column 1416(e.g. column width constraints, font and icon for the column 1417title etc.)&] 1418[s3; &] 1419[s4; &] 1420[s5;:ArrayCtrl`:`:HeaderTab`(const Id`&`): [_^HeaderCtrl`:`:Column^ HeaderCtrl`::Column][@(0.0.255) `& 1421]_[* HeaderTab]([@(0.0.255) const ][_^Id^ Id]`&_[*@3 id])&] 1422[s2; Returns the [* HeaderCtrl`::Column] descriptive structure for the 1423column bound to a given source index.&] 1424[s7; [*C@3 id]-|identifier of the index used as source for the column&] 1425[s7; [*/ Return value]-|a reference to the [* HeaderCtrl`::Column] structure&] 1426[s3; &] 1427[s4; &] 1428[s5;:ArrayCtrl`:`:HeaderTab`(const Id`&`)const: [@(0.0.255) const]_[_^HeaderCtrl`:`:Column^ H 1429eaderCtrl`::Column][@(0.0.255) `&]_[* HeaderTab]([@(0.0.255) const ][_^Id^ Id]`&_[*@3 id])_[@(0.0.255) c 1430onst]&] 1431[s2; Returns a constant reference to the [* HeaderCtrl`::Column] descriptive 1432structure for the column bound to a given source index.&] 1433[s7; [*C@3 id]-|identifier of the index used as source for the column&] 1434[s7; [*/ Return value]-|a constant reference to the [* HeaderCtrl`::Column] 1435structure&] 1436[s3; &] 1437[s4; &] 1438[s5;:ArrayCtrl`:`:HeaderObject`(`)const: [@(0.0.255) const]_[_^HeaderCtrl^ HeaderCtrl][@(0.0.255) `& 1439]_[* HeaderObject]()_[@(0.0.255) const]&] 1440[s2; Returns a non`-constant reference to the [* HeaderCtrl] object 1441for this table. The reference can be further used to alter properties 1442of the table header (tab visibility, header visual mode and so 1443on).&] 1444[s7; [*/ Return value]-|A non`-constant reference to the table HeaderCtrl 1445object.&] 1446[s3; &] 1447[s4; &] 1448[s5;:ArrayCtrl`:`:HeaderObject`(`): [_^HeaderCtrl^ HeaderCtrl][@(0.0.255) `&]_[* HeaderObje 1449ct]()&] 1450[s2; This is just the constant version of the above method; when 1451called on a constant [* ArrayCtrl] reference, it returns a constant 1452reference to its underlying HeaderCtrl object which can be then 1453used to query additional header information.&] 1454[s7; [*/ Return value]-|A constant reference to the table HeaderCtrl 1455object.&] 1456[s3; &] 1457[s4; &] 1458[s5;:ArrayCtrl`:`:SerializeHeader`(Stream`&`): [@(0.0.255) void]_[* SerializeHeader]([_^Stream^ S 1459tream][@(0.0.255) `&]_[*@3 s])&] 1460[s2; Serializes all information pertaining to the array header (mainly 1461the user`-set column widths). This is equivalent to calling [* HeaderObject().Seria 1462lize(s)]. The main purpose of this function is to allow storing 1463header configuration to be restored upon opening the dialog or 1464the application for the next time. This function is now deprecated 1465in favor of SerializeSettings.&] 1466[s7; [*C@3 s]-|the [*^topic`:`/`/Core`/src`/Stream`$en`-us^ Stream] object 1467to serialize the header to/from&] 1468[s3; &] 1469[s4; &] 1470[s5;:ArrayCtrl`:`:SerializeSettings`(Stream`&`): [@(0.0.255) void]_[* SerializeSettings]( 1471[_^Stream^ Stream][@(0.0.255) `&]_[*@3 s])&] 1472[s2; Serializes all information pertaining to the array header (mainly 1473the user`-set column widths) and the setting of sort column. 1474The main purpose of this function is to allow storing configuration 1475to be restored upon opening the dialog or the application for 1476the next time.&] 1477[s3; &] 1478[s4; &] 1479[s5;:ArrayCtrl`:`:SetDisplay`(int`,int`,const Display`&`): [@(0.0.255) void]_[* SetDispla 1480y]([@(0.0.255) int]_[*@3 i], [@(0.0.255) int]_[*@3 col], [@(0.0.255) const]_[_^Display^ Displ 1481ay][@(0.0.255) `&]_[*@3 d])&] 1482[s2; Sets the [* Display] object for a given array cell.&] 1483[s2;* &] 1484[s2; [* Note:] the ownership to the Display object is not transferred 1485by this call. The ArrayCtrl stores a mere pointer to it and it 1486is the responsibility of the programmer to keep the Display object 1487alive as long as necessary (until the array is shut down or the 1488cell display changed via another call to SetDisplay). In fact, 1489most Display`-based objects don`'t support data copying at all. 1490In any case, copying Displays is not a very good practice and 1491is very prone to slicing (as most actual Displays are actually 1492derived classes with additional data members).&] 1493[s2; &] 1494[s2; In many cases it would be relatively safe to assume that the 1495Display is not used unless the array is actually painted (e.g., 1496when the control is not bound to a parent or when its view has 1497zero size), but it is not a very wise practice and it can fail 1498in very weird ways under special circumstances (like making screenshots 1499or graphical exports from the array control).&] 1500[s2; &] 1501[s7; [*C@3 i]-|zero`-based row index&] 1502[s7; [*C@3 j]-|zero`-based column index&] 1503[s7; [*C@3 d]-|display to use&] 1504[s3; &] 1505[s4;%- &] 1506[s5;:Upp`:`:ArrayCtrl`:`:SetRowDisplay`(int`,const Upp`:`:Display`&`):%- [@(0.0.255) vo 1507id]_[* SetRowDisplay]([@(0.0.255) int]_[*@3 i], [@(0.0.255) const]_[_^Upp`:`:Display^ Displ 1508ay][@(0.0.255) `&]_[*@3 d])&] 1509[s2; Sets Display [%-*@3 d] for each cell of line [%-*@3 i].&] 1510[s3; &] 1511[s4;%- &] 1512[s5;:Upp`:`:ArrayCtrl`:`:SetColumnDisplay`(int`,const Upp`:`:Display`&`):%- [@(0.0.255) v 1513oid]_[* SetColumnDisplay]([@(0.0.255) int]_[*@3 j], [@(0.0.255) const]_[_^Upp`:`:Display^ D 1514isplay][@(0.0.255) `&]_[*@3 d])&] 1515[s2; Sets Display [%-*@3 d] for each cell of column j.&] 1516[s3; &] 1517[s4; &] 1518[s5;:ArrayCtrl`:`:GetDisplay`(int`,int`): [@(0.0.255) const]_[_^Display^ Display][@(0.0.255) `& 1519]_[* GetDisplay]([@(0.0.255) int]_[*@3 row], [@(0.0.255) int]_[*@3 col])&] 1520[s2; Returns a reference to the Display object for the given array 1521cell.&] 1522[s7; [*C@3 row]-|zero`-based row index&] 1523[s7; [*C@3 col]-|zero`-based column index&] 1524[s7; [*/ Return value]-|a reference to the Display object.&] 1525[s3; &] 1526[s4; &] 1527[s5;:ArrayCtrl`:`:GetDisplay`(int`): [@(0.0.255) const]_[_^Display^ Display][@(0.0.255) `&]_ 1528[* GetDisplay]([@(0.0.255) int]_[*@3 col])&] 1529[s2; Returns a reference to the Display object for the given array 1530column.&] 1531[s7; [*C@3 col]-|zero`-based column index&] 1532[s7; [*/ Return value]-|constant reference to the column Display&] 1533[s3; &] 1534[s4; &] 1535[s5;:ArrayCtrl`:`:SetCtrl`(int`,int`,Ctrl`&`,bool`): [@(0.0.255) void]_[* SetCtrl]([@(0.0.255) i 1536nt]_[*@3 i], [@(0.0.255) int]_[*@3 col], [_^Ctrl^ Ctrl][@(0.0.255) `&]_[*@3 ctrl], 1537[@(0.0.255) bool]_[*@3 value]_`=_[@(0.0.255) true])&] 1538[s2; Sets an external control to use as the editor for a single array 1539cell. Naturally, the same Ctrl object cannot be used as the editor 1540for multiple array cells. If the position of Ctrl is equivalent 1541to `'SetRect(0, 0, 0, 0)`', which is the default value, Ctrl 1542is resized to fit the ArrayCtrl cell accurately, spanning the 1543whole width and using STDSIZE for height, otherwise the position 1544represents the position within the cell. If [*@3 value] is true, 1545then the Ctrl represents the value of the cell, otherwise it 1546is independent of it.&] 1547[s3; &] 1548[s4; &] 1549[s5;:ArrayCtrl`:`:GetCtrl`(int`,int`): [_^Ctrl^ Ctrl]_`*[* GetCtrl]([@(0.0.255) int]_[*@3 i], 1550 [@(0.0.255) int]_[*@3 col])&] 1551[s2; Returns a pointer to ctrl if there is any, NULL otherwise.&] 1552[s3; &] 1553[s4; &] 1554[s5;:ArrayCtrl`:`:CreateCtrl`(int`,int`,bool`): [@(0.0.255) template]_<[@(0.0.255) class]_ 1555[*@4 T]>_[*@4 T][@(0.0.255) `&]_[* CreateCtrl]([@(0.0.255) int]_[*@3 i], 1556[@(0.0.255) int]_[*@3 col], [@(0.0.255) bool]_[*@3 value]_`=_[@(0.0.255) true])&] 1557[s2; Creates an control (owned by ArrayCtrl) for a single array cell. 1558If [*@3 value] is true, then the Ctrl represents the value of the 1559cell, otherwise it is independent of it. If the position of Ctrl 1560is equivalent to `'SetRect(0, 0, 0, 0)`', which is the default 1561value, Ctrl is resized to fit the ArrayCtrl cell accurately, 1562spanning the whole width and using STDSIZE for height, otherwise 1563the position represents the position within the cell. &] 1564[s3; &] 1565[s4; &] 1566[s5;:ArrayCtrl`:`:GetTotalCy`(`)const: [@(0.0.255) int]_[* GetTotalCy]()_[@(0.0.255) const]&] 1567[s2; Returns total height of the array (sum of the individual line 1568heights for all array rows)&] 1569[s7; [*/ Return value]-|array height in pixels&] 1570[s3; &] 1571[s4; &] 1572[s5;:ArrayCtrl`:`:GetLineAt`(int`)const: [@(0.0.255) int]_[* GetLineAt]([@(0.0.255) int]_[*@3 y 1573])_[@(0.0.255) const]&] 1574[s2; Locates the array row according to given [/ y] coordinate (such 1575array row [/ r] for which [* GetLineY(r) <`= y `&`& GetLineY(r) `+ 1576GetLineCy(r) > y]).&] 1577[s7; [*C@3 y]-|vertical pixel coordinate to locate&] 1578[s7; [*/ Return value]-|zero`-based row number or `-1 when not found&] 1579[s3; &] 1580[s4;%- &] 1581[s5;:Upp`:`:ArrayCtrl`:`:SetLineColor`(int`,Upp`:`:Color`):%- [@(0.0.255) void]_[* SetLin 1582eColor]([@(0.0.255) int]_[*@3 i], [_^Upp`:`:Color^ Color]_[*@3 c])&] 1583[s2; Sets the background color of line [%-*@3 i] to [%-*@3 c].&] 1584[s3; &] 1585[s4;%- &] 1586[s5;:Upp`:`:ArrayCtrl`:`:GetCellRect`(int`,int`)const:%- [_^Upp`:`:Rect^ Rect]_[* GetCell 1587Rect]([@(0.0.255) int]_[*@3 i], [@(0.0.255) int]_[*@3 col])_[@(0.0.255) const]&] 1588[s2; Returns rectangle of cell at [%-*@3 i],[%-*@3 col] in view coordinates. 1589Cell left and right margins are included in rectangle.&] 1590[s3; &] 1591[s4;%- &] 1592[s5;:Upp`:`:ArrayCtrl`:`:GetCellRectM`(int`,int`)const:%- [_^Upp`:`:Rect^ Rect]_[* GetCel 1593lRectM]([@(0.0.255) int]_[*@3 i], [@(0.0.255) int]_[*@3 col])_[@(0.0.255) const]&] 1594[s2; Returns rectangle of cell at [%-*@3 i],[%-*@3 col] in view coordinates. 1595Cell left and right margins are not included in rectangle.&] 1596[s3; &] 1597[s4;%- &] 1598[s5;:Upp`:`:ArrayCtrl`:`:GetScreenCellRect`(int`,int`)const:%- [_^Upp`:`:Rect^ Rect]_[* G 1599etScreenCellRect]([@(0.0.255) int]_[*@3 i], [@(0.0.255) int]_[*@3 col])_[@(0.0.255) const]&] 1600[s2; Returns rectangle of cell at [%-*@3 i],[%-*@3 col] in screen coordinates. 1601Cell left and right margins are included in rectangle.&] 1602[s3; &] 1603[s4;%- &] 1604[s5;:Upp`:`:ArrayCtrl`:`:GetScreenCellRectM`(int`,int`)const:%- [_^Upp`:`:Rect^ Rect]_[* G 1605etScreenCellRectM]([@(0.0.255) int]_[*@3 i], [@(0.0.255) int]_[*@3 col])_[@(0.0.255) const]&] 1606[s2; Returns rectangle of cell at [%-*@3 i],[%-*@3 col] in screen coordinates. 1607Cell left and right margins are not included in rectangle.&] 1608[s3; &] 1609[s4; &] 1610[s5;:ArrayCtrl`:`:GetClickColumn`(`)const: [@(0.0.255) int]_[* GetClickColumn]()_[@(0.0.255) c 1611onst]&] 1612[s2; Returns column index of the last clicked column in the array. 1613If the click happens past the last row of array, returns Null.&] 1614[s7; [*/ Return value]-|zero`-based index of the relevant column&] 1615[s3; &] 1616[s4; &] 1617[s5;:ArrayCtrl`:`:GetClickRow`(`)const: [@(0.0.255) int]_[* GetClickRow]()_[@(0.0.255) cons 1618t]&] 1619[s2; Returns column index of the last clicked row in the array. If 1620the click happens past the last row of array, returns Null.&] 1621[s7; [*/ Return value]-|zero`-based index of the relevant column&] 1622[s3; &] 1623[s4; &] 1624[s5;:ArrayCtrl`:`:GetClickPos`(`)const: [_^Point^ Point]_[* GetClickPos]()_[@(0.0.255) cons 1625t]&] 1626[s7; [*/ Return value]-|[* Point(GetClickColumn(), GetClickRow())].&] 1627[s3; &] 1628[s0;* &] 1629[s0; [* Data setting and retrieval]&] 1630[s3; &] 1631[s0; &] 1632[s5;:ArrayCtrl`:`:SetCount`(int`): [@(0.0.255) void]_[* SetCount]([@(0.0.255) int]_[*@3 c])&] 1633[s2; Sets the number of rows in the array. This extends or trims 1634the source matrix as necessary. When using the Ctrl`-based individual 1635cell editors, as a side`-effect of this call some controls can 1636be constructed or destroyed.&] 1637[s7; [*C@3 c]-|new row count&] 1638[s3; &] 1639[s4; &] 1640[s5;:ArrayCtrl`:`:SetVirtualCount`(int`): [@(0.0.255) void]_[* SetVirtualCount]([@(0.0.255) i 1641nt]_[*@3 c])&] 1642[s2; Sets the number of rows in an array with external data. This 1643makes sense only when all the [/ Column`'s] and [/ Ctrl`'s] of the 1644array are [/ rownum]`-based. The function doesn`'t physically allocate 1645any source data matrix space, it just makes the array `'think`' 1646it has [/ c] rows (this is of course necessary for the Paint routine, 1647for cursor / selection management and so on).&] 1648[s2; [* Note:] in the current implementation, selection flags for the 1649individual rows are kept in the row objects. Therefore it is 1650not very wise to use multiselection for arrays with external 1651data, because as soon as the last row is selected, all row storage 1652structures are allocated as a side effect to keep the selection 1653flags.&] 1654[s7; [*C@3 c]-|new `'virtual`' number of rows&] 1655[s3; &] 1656[s4; &] 1657[s5;:ArrayCtrl`:`:GetCount`(`)const: [@(0.0.255) int]_[* GetCount]()_[@(0.0.255) const]&] 1658[s2; Returns the number of rows in the array. In fact, this returns 1659the maximum of the number of `'real`' source matrix rows (as 1660set by the SetCount / Add / Insert methods) and the `'virtual`' 1661row count (as se by SetVirtualCount). By checking the implementation 1662of this method, you can easily find that, simply,&] 1663[s2; &] 1664[s2; [C int ArrayCtrl`::GetCount() const `{]&] 1665[s2; [C -|-|return max(virtualcount, array.GetCount());]&] 1666[s2; [C `}]&] 1667[s2; &] 1668[s7; [*/ Return value]-|Number of rows in the array.&] 1669[s3; &] 1670[s4; &] 1671[s5;:ArrayCtrl`:`:Clear`(`): [@(0.0.255) void]_[* Clear]()&] 1672[s2; Clears the array source data matrix and sets the virtual row 1673count to 0.&] 1674[s3; &] 1675[s4; &] 1676[s5;:ArrayCtrl`:`:Shrink`(`): [@(0.0.255) void]_[* Shrink]()&] 1677[s2; Shrinks the source data array, i.e. reallocates the data to 1678the minimum required memory space.&] 1679[s3; &] 1680[s4; &] 1681[s5;:ArrayCtrl`:`:Get`(int`,int`)const: [_^Value^ Value]_[* Get]([@(0.0.255) int]_[*@3 i], 1682[@(0.0.255) int]_[*@3 ii])_[@(0.0.255) const]&] 1683[s2; Returns the value at a given location in the source data matrix.&] 1684[s7; [*C@3 i]-|zero`-based row number&] 1685[s7; [*C@3 ii]-|zero`-based index ordinal number&] 1686[s7; [*/ Return value]-|value at the given location in the source data 1687matrix&] 1688[s3; &] 1689[s4; &] 1690[s5;:ArrayCtrl`:`:Get`(int`,const Id`&`)const: [_^Value^ Value]_[* Get]([@(0.0.255) int]_[*@3 i 1691], [@(0.0.255) const ][_^Id^ Id]`&_[*@3 id])_[@(0.0.255) const]&] 1692[s2; Returns the value at a given location in the source data matrix. 1693In this version, the source indices are addressed by their identifiers.&] 1694[s7; [*C@3 i]-|zero`-based row number&] 1695[s7; [*C@3 id]-|source index identifier&] 1696[s7; [*/ Return value]-|value at the given location in the source data 1697matrix&] 1698[s3; &] 1699[s4; &] 1700[s5;:ArrayCtrl`:`:Get`(int`)const: [_^Value^ Value]_[* Get]([@(0.0.255) int]_[*@3 ii])_[@(0.0.255) c 1701onst]&] 1702[s2; Returns the value of a given source index at the currently active 1703cursor row. This is equivalent to [* Get(GetCursor(), ii)]. When 1704the row is currently being edited, the function returns the `'new`' 1705value (the current value of the respective editor control, i.e. 1706potentially edited).&] 1707[s2; [* Note:] when the cursor row is not set (when [* !IsCursor()]), 1708the function fails with an [* ASSERT].&] 1709[s7; [*C@3 ii]-|zero`-based index ordinal number&] 1710[s7; [*/ Return value]-|value at a given location in the cursor row&] 1711[s3; &] 1712[s4; &] 1713[s5;:ArrayCtrl`:`:Get`(const Id`&`)const: [_^Value^ Value]_[* Get]([@(0.0.255) const 1714][_^Id^ Id]`&_[*@3 id])_[@(0.0.255) const]&] 1715[s2; Returns the value of a given source index at the currently active 1716cursor row. This is equivalent to [* Get(GetCursor(), id)].&] 1717[s7; [*C@3 id]-|source index identifier&] 1718[s7; [*/ Return value]-|value at the given location in the cursor row&] 1719[s3; &] 1720[s4; &] 1721[s5;:ArrayCtrl`:`:GetOriginal`(int`)const: [_^Value^ Value]_[* GetOriginal]([@(0.0.255) int 1722]_[*@3 ii])_[@(0.0.255) const]&] 1723[s2; Returns the `'original`' value of a given source index at the 1724currently active cursor row. When the row is open for editing, 1725this function returns the `'old`' value before any editing took 1726place.&] 1727[s7; [*C@3 ii]-|zero`-based index ordinal number&] 1728[s7; [*/ Return value]-|value at the given location in the cursor row&] 1729[s3; &] 1730[s4; &] 1731[s5;:ArrayCtrl`:`:GetOriginal`(const Id`&`)const: [_^Value^ Value]_[* GetOriginal]([@(0.0.255) c 1732onst ][_^Id^ Id]`&_[*@3 id])_[@(0.0.255) const]&] 1733[s2; Returns the `'original`' value (i.e., without any editing changed 1734applied) of a given source index at the currently active cursor 1735row.&] 1736[s7; [*C@3 id]-|source index identifier&] 1737[s7; [*/ Return value]-|value at the given location in the cursor row&] 1738[s3; &] 1739[s4; &] 1740[s5;:ArrayCtrl`:`:GetKey`(`)const: [_^Value^ Value]_[* GetKey]()_[@(0.0.255) const]&] 1741[s2; Returns the value of the current row`'s primary key. This is 1742equivalent to [* Get(0)].&] 1743[s7; [*/ Return value]-|value at the index #0 in the cursor row&] 1744[s3; &] 1745[s4; &] 1746[s5;:ArrayCtrl`:`:GetOriginalKey`(`)const: [_^Value^ Value]_[* GetOriginalKey]()_[@(0.0.255) c 1747onst]&] 1748[s2; Returns the original value of the current row`'s primary key. 1749During editing, the function returns the value at the time of 1750opening the row for editing, i.e. without any editing changes 1751applied. This is equivalent to [* GetOriginal(0)].&] 1752[s7; [*/ Return value]-|value at the index #0 in the cursor row&] 1753[s3; &] 1754[s4; &] 1755[s5;:ArrayCtrl`:`:Set`(int`,int`,const Value`&`): [@(0.0.255) void]_[* Set]([@(0.0.255) int 1756]_[*@3 i], [@(0.0.255) int]_[*@3 ii], [@(0.0.255) const]_[_^Value^ Value][@(0.0.255) `&]_[*@3 v 1757])&] 1758[s2; Sets the value at a given location in the source data matrix.&] 1759[s7; [*C@3 i]-|zero`-based row number&] 1760[s7; [*C@3 ii]-|zero`-based index ordinal number&] 1761[s7; [*C@3 v]-|value to set to the given cell&] 1762[s3; &] 1763[s4; &] 1764[s5;:ArrayCtrl`:`:Set`(int`,const Id`&`,const Value`&`): [@(0.0.255) void]_[* Set]([@(0.0.255) i 1765nt]_[*@3 i], [@(0.0.255) const ][_^Id^ Id]`&_[*@3 id], [@(0.0.255) const]_[_^Value^ Value][@(0.0.255) `& 1766]_[*@3 v])&] 1767[s2; Sets the value at a given location in the source data matrix. 1768&] 1769[s7; [*C@3 i]-|zero`-based row number&] 1770[s7; [*C@3 id]-|source index identifier&] 1771[s7; [*C@3 v]-|value to set to the given cell&] 1772[s3; &] 1773[s4; &] 1774[s5;:ArrayCtrl`:`:Set`(int`,const Value`&`): [@(0.0.255) void]_[* Set]([@(0.0.255) int]_[*@3 i 1775i], [@(0.0.255) const]_[_^Value^ Value][@(0.0.255) `&]_[*@3 v])&] 1776[s2; Modifies the value at a given location in the cursor row. When 1777the row is open for editing, the function immediately changes 1778the value in the appropriate editor control.&] 1779[s7; [*C@3 ii]-|zero`-based index ordinal number&] 1780[s7; [*C@3 v]-|value to set&] 1781[s3; &] 1782[s4; &] 1783[s5;:ArrayCtrl`:`:Set`(const Id`&`,const Value`&`): [@(0.0.255) void]_[* Set]([@(0.0.255) c 1784onst ][_^Id^ Id]`&_[*@3 id], [@(0.0.255) const]_[_^Value^ Value][@(0.0.255) `&]_[*@3 v])&] 1785[s2; Modifies the value at a given location in the cursor row. This 1786overloaded version uses the [* Id] identifier to address the relevant 1787index.&] 1788[s7; [*C@3 id]-|index identifier&] 1789[s7; [*C@3 v]-|value to set&] 1790[s3; &] 1791[s4; &] 1792[s5;:ArrayCtrl`:`:GetColumn`(int`,int`)const: [_^Value^ Value]_[* GetColumn]([@(0.0.255) in 1793t]_[*@3 row], [@(0.0.255) int]_[*@3 col])_[@(0.0.255) const]&] 1794[s2; Returns the value of a given column. This depends on the column`-index 1795mapping established when adding columns to the table. When the 1796column is a [/ rownum] type (it is bound to no source indices), 1797the function just returns the [/ row] parameter. For columns with 1798a single source index, the function returns the value of the 1799mapped source index. For columns with multiple source indices, 1800the function returns a [* ValueArray ]containing the values of 1801its source indices.&] 1802[s7; [*C@3 row]-|zero`-based row index&] 1803[s7; [*C@3 col]-|zero`-based column index&] 1804[s7; [*/ Return value]-|value of the given column&] 1805[s3; &] 1806[s4; &] 1807[s5;:ArrayCtrl`:`:GetConvertedColumn`(int`,int`): [_^Value^ Value]_[* GetConvertedColumn]( 1808[@(0.0.255) int]_[*@3 row], [@(0.0.255) int]_[*@3 col])&] 1809[s2; Returns the value of a given column after application of its 1810[* Convert]. For performance reasons, the values obtained by calls 1811to the [* Convert`::Format] methods are cached internally within 1812the ArrayCtrl object. You can manipulate the conversion cache 1813using the methods [*^topic`:`/`/CtrlLib`/src`/ArrayCtrl`$en`-us`#`:`:ArrayCtrl`:`:ClearCache`(`)^ C 1814learCache] and[* ][*^topic`:`/`/CtrlLib`/src`/ArrayCtrl`$en`-us`#`:`:ArrayCtrl`:`:InvalidateCache`(int`)^ I 1815nvalidateCache].&] 1816[s7; [*C@3 row]-|zero`-based row index&] 1817[s7; [*C@3 col]-|zero`-based column index&] 1818[s7; [*/ Return value]-|the converted cell value&] 1819[s3; &] 1820[s4; &] 1821[s5;:ArrayCtrl`:`:ReadRow`(int`)const: [_^Vector^ Vector]<[_^Value^ Value]>_[* ReadRow]([@(0.0.255) i 1822nt]_[*@3 i])_[@(0.0.255) const]&] 1823[s2; Returns a [* Vector] containing the values of all source indices 1824in the given row. Invariantly, the [* GetCount()] of the returned 1825array is equal to the [* GetIndexCount()] of the source ArrayCtrl.&] 1826[s7; [*C@3 i]-|zero`-based row index&] 1827[s7; [*/ Return value]-|an array of all source values in the given row&] 1828[s3; &] 1829[s4; &] 1830[s5;:ArrayCtrl`:`:Set`(int`,const Vector`<Value`>`&`): [@(0.0.255) void]_[* Set]([@(0.0.255) i 1831nt]_[*@3 i], [@(0.0.255) const]_[_^Vector^ Vector]<[_^Value^ Value]>`&_[*@3 v])&] 1832[s2; Modifies a given row by setting all source index values to values 1833passed in the parameter [/ v].&] 1834[s3; &] 1835[s4; &] 1836[s5;:ArrayCtrl`:`:SetArray`(int`,const ValueArray`&`): [@(0.0.255) void]_[* SetArray]([@(0.0.255) i 1837nt]_[*@3 i], [@(0.0.255) const]_[_^ValueArray^ ValueArray][@(0.0.255) `&]_[*@3 va])&] 1838[s2; Sets the row [*@3 i] to [*@3 va].&] 1839[s3; &] 1840[s4; &] 1841[s5;:ArrayCtrl`:`:Add`(`): [@(0.0.255) void]_[* Add]()&] 1842[s2; Adds an empty row to the source data matrix.&] 1843[s2; [* Note:] the [* InsertValue] property of the [* IdInfo] structure 1844defines a method to generate / retrieve default values for newly 1845inserted rows. However, these values are only used during the 1846GUI`-based [* DoInsert] method and do not apply to the [* Add] method. 1847If you need to set the newly added source matrix row to some 1848non`-null defaults, you have to modify the relevant cells manually.&] 1849[s3; &] 1850[s4; &] 1851[s5;:ArrayCtrl`:`:Add`(const Vector`<Value`>`&`): [@(0.0.255) void]_[* Add]([@(0.0.255) con 1852st]_[_^Vector^ Vector]<[_^Value^ Value]>`&_[*@3 v])&] 1853[s2; Adds a new row at the end of the source data matrix. The [*^topic`:`/`/Core`/src`/Vector`$en`-us^ V 1854ector] parameter contains the values to be used to initialize 1855the new row of the matrix.&] 1856[s7; [*C@3 v]-|new matrix row&] 1857[s3; &] 1858[s4; &] 1859[s5;:ArrayCtrl`:`:AddArray`(const ValueArray`&`): [@(0.0.255) void]_[* AddArray]([@(0.0.255) c 1860onst]_[_^ValueArray^ ValueArray][@(0.0.255) `&]_[*@3 va])&] 1861[s2; Adds a new row at the end of source with value [*@3 va].&] 1862[s3; &] 1863[s4; &] 1864[s5;:ArrayCtrl`:`:GetArray`(int`)const: [_^ValueArray^ ValueArray]_[* GetArray]([@(0.0.255) i 1865nt]_[*@3 i])_[@(0.0.255) const]&] 1866[s2; Returns a row as ValueArray.&] 1867[s3; &] 1868[s4; &] 1869[s5;:ArrayCtrl`:`:Set`(int`,const VectorMap`<String`,Value`>`&`): [@(0.0.255) void]_[* Se 1870t]([@(0.0.255) int]_[*@3 i], [@(0.0.255) const]_[_^VectorMap^ VectorMap]<[_^String^ String], 1871 [_^Value^ Value]>`&_[*@3 m])&] 1872[s2; Sets the row based on map. Keys are matched to row Ids, keys 1873that are not found are ignored, those found are assigned correspoding 1874map values.&] 1875[s3; &] 1876[s4; &] 1877[s5;:ArrayCtrl`:`:Add`(const VectorMap`<String`,Value`>`&`): [@(0.0.255) void]_[* Add]([@(0.0.255) c 1878onst]_[_^VectorMap^ VectorMap]<[_^String^ String], [_^Value^ Value]>`&_[*@3 m])&] 1879[s2; Adds the row based on map. Keys are matched to row Ids, keys 1880that are not found are ignored, those found are assigned correspoding 1881map values.&] 1882[s3; &] 1883[s4; &] 1884[s5;:ArrayCtrl`:`:SetMap`(int`,const ValueMap`&`): [@(0.0.255) void]_[* SetMap]([@(0.0.255) i 1885nt]_[*@3 i], [@(0.0.255) const]_[_^ValueMap^ ValueMap][@(0.0.255) `&]_[*@3 m])&] 1886[s2; Sets the row based on map. Keys are matched to row Ids, keys 1887that are not found are ignored, those found are assigned correspoding 1888map values.&] 1889[s3; &] 1890[s4; &] 1891[s5;:ArrayCtrl`:`:AddMap`(const ValueMap`&`): [@(0.0.255) void]_[* AddMap]([@(0.0.255) cons 1892t]_[_^ValueMap^ ValueMap][@(0.0.255) `&]_[*@3 m])&] 1893[s2; Adds the row based on map. Keys are matched to row Ids, keys 1894that are not found are ignored, those found are assigned correspoding 1895map values.&] 1896[s3; &] 1897[s4; &] 1898[s5;:ArrayCtrl`:`:GetMap`(int`)const: [_^ValueMap^ ValueMap]_[* GetMap]([@(0.0.255) int]_[*@3 i 1899])_[@(0.0.255) const]&] 1900[s2; Returns row as map of row Ids to row values. Only non`-empty 1901row Ids are added.&] 1902[s3; &] 1903[s4; &] 1904[s5;:ArrayCtrl`:`:Add`(const Value`&`[`,const Value`&`]`.`.`.`): [@(0.0.255) void]_[* Add 1905]([@(0.0.255) const]_[_^Value^ Value][@(0.0.255) `&]_`[, [@(0.0.255) const]_[_^Value^ Value 1906][@(0.0.255) `&]_`]...)&] 1907[s2; Adds a new row at the bottom of the source data matrix. This 1908is in fact a series of functions (generated automatically using 1909the [* Expand] macro) which takes an arbitrary number of arguments. 1910Its arguments are used to initialize the source indices in the 1911newly added row.&] 1912[s3; &] 1913[s4; &] 1914[s5;:ArrayCtrl`:`:Add`(const Nuller`&`): [@(0.0.255) void]_[* Add]([@(0.0.255) const]_[_^Nuller^ N 1915uller][@(0.0.255) `&]_[*@3 null])&] 1916[s2; This is helper method required for correct overloading resolution 1917of Add(Null).&] 1918[s3; &] 1919[s4; &] 1920[s5;:ArrayCtrl`:`:Insert`(int`): [@(0.0.255) void]_[* Insert]([@(0.0.255) int]_[*@3 i])&] 1921[s2; Inserts a new row into the source array. All indices are initialized 1922to [* Null] values. The [* InsertValue] property doesn`'t apply; 1923if you need to set the newly created row to some non`-trivial 1924values, you have to do so manually.&] 1925[s7; [*C@3 i]-|zero`-based position of the newly created row&] 1926[s3; &] 1927[s4; &] 1928[s5;:ArrayCtrl`:`:Insert`(int`,const Vector`<Value`>`&`): [@(0.0.255) void]_[* Insert]([@(0.0.255) i 1929nt]_[*@3 i], [@(0.0.255) const]_[_^Vector^ Vector]<[_^Value^ Value]>`&_[*@3 v])&] 1930[s2; Inserts a new row into the array at a given position. The second 1931parameter, [/ v], is used to initialize the source indices of the 1932newly created row.&] 1933[s7; [*C@3 i]-|zero`-based row index&] 1934[s7; [*C@3 v]-|a vector of values used to initialize the source indices 1935of the given row&] 1936[s3; &] 1937[s4; &] 1938[s5;:ArrayCtrl`:`:Remove`(int`): [@(0.0.255) void]_[* Remove]([@(0.0.255) int]_[*@3 i])&] 1939[s2; Removes the given source data row.&] 1940[s2; [* Note:] the [* AskRemove] property of the [* ArrayCtrl] object tells 1941whether a confirmation dialog should pop up every time the user 1942wants to remove a row. However, this method applies only to the 1943GUI`-based row removal; the [* Remove] method always removes the 1944requested row unconditionally without popping up any confirmation 1945dialog.&] 1946[s7; [*C@3 i]-|zero`-based index of the row to remove&] 1947[s3; &] 1948[s4; &] 1949[s5;:ArrayCtrl`:`:SwapUp`(`): [@(0.0.255) void]_[* SwapUp]()&] 1950[s2; Exchanges the cursor row with the preceding row, effectively 1951moving it up.&] 1952[s3; &] 1953[s4; &] 1954[s5;:ArrayCtrl`:`:SwapDown`(`): [@(0.0.255) void]_[* SwapDown]()&] 1955[s2; Exchanges the cursor row with following row, effectively moving 1956it down.&] 1957[s3; &] 1958[s4;%- &] 1959[s5;:Upp`:`:ArrayCtrl`:`:ReArrange`(const Upp`:`:Vector`<int`>`&`):%- [@(0.0.255) void]_ 1960[* ReArrange]([@(0.0.255) const]_[_^Upp`:`:Vector^ Vector]<[@(0.0.255) int]>`&_[*@3 order]) 1961&] 1962[s2; Rearranges lines of array by [%-*@3 order] of former line indices. 1963The count of items in [%-*@3 order] must be the same as GetCount 1964of ArrayCtrl and it must contain all indices from zero to GetCount() 1965`- 1. [%-*@3 order] establishes a new order expressed in former 1966indices of lines.&] 1967[s3; &] 1968[s4; &] 1969[s5;:ArrayCtrl`:`:Sort`(Gate2`<int`,int`>`): [@(0.0.255) void]_[* Sort]([_^Gate2^ Gate2]<[@(0.0.255) i 1970nt], [@(0.0.255) int]>_[*@3 order])&] 1971[s5;:ArrayCtrl`:`:Sort`(int`,int`,Gate2`<int`,int`>`): [@(0.0.255) void]_[* Sort]([@(0.0.255) i 1972nt]_[*@3 from], [@(0.0.255) int]_[*@3 count], [_^Gate2^ Gate2]<[@(0.0.255) int], 1973[@(0.0.255) int]>_[*@3 order])&] 1974[s2; Sorts the array rows according to a given ordering predicate. 1975The [*@3 order] object defines the ordering predicate; two parameters 1976are indicies of ArrayCtrl lines; it should returns true if they 1977are in required ordering.&] 1978[s3; &] 1979[s4; &] 1980[s5;:ArrayCtrl`:`:Sort`(const ArrayCtrl`:`:Order`&`): [@(0.0.255) void]_[* Sort]([@(0.0.255) c 1981onst]_[_^ArrayCtrl`:`:Order^ ArrayCtrl`::Order][@(0.0.255) `&]_[*@3 order])&] 1982[s2; Sorts the array rows according to a given ordering predicate. 1983The [* ArrayCtrl`::Order] object defines the ordering predicate; 1984its [* operator ()] should return [* true] whenever its first parameter 1985(a vector containing the values of all source indices in a row) 1986is less than its second parameter.&] 1987[s7; &] 1988[s3; &] 1989[s4; &] 1990[s5;:ArrayCtrl`:`:Sort`(int`,int`,const ArrayCtrl`:`:Order`&`): [@(0.0.255) void]_[* Sort 1991]([@(0.0.255) int]_[*@3 from], [@(0.0.255) int]_[*@3 count], [@(0.0.255) const]_[_^ArrayCtrl`:`:Order^ A 1992rrayCtrl`::Order][@(0.0.255) `&]_[*@3 order])&] 1993[s2; Sorts a portion of the array using a given ordering predicate.&] 1994[s7; [*C@3 from]-|zero`-based index of the first row to sort&] 1995[s7; [*C@3 count]-|number of rows to be sorted&] 1996[s7; [*C@3 order]-|the ordering predicate object. The object should 1997be derived from [* ArrayCtrl`::Order] and should override the [* operator 1998()] method. This method should return [* true ]whenever its first 1999parameter (a vector containing all source index values for a 2000certain row) is less than its second parameter.&] 2001[s3; &] 2002[s4; &] 2003[s5;:ArrayCtrl`:`:Sort`(int`(`*`)`(const Vector`<Value`>`&v1`,const Vector`<Value`>`&v2`)`): [@(0.0.255) v 2004oid]_[* Sort]([@(0.0.255) int]_(`*[*@3 compare])([@(0.0.255) const]_Vector<Value>`&_v1, 2005[@(0.0.255) const]_Vector<Value>`&_v2))&] 2006[s2; Sorts the array rows according to the order defined by the specified 2007ordering predicate [/ compare]. This is supposed to be a global 2008function returning [* true] whenever its first parameter ([/ v1], 2009an array consisting of all source indices within a row) is less 2010than the second parameter [/ v2] (according to the desired ordering).&] 2011[s7; [*C@3 compare]-|the ordering predicate; _the function is supposed 2012to return [* true] whenever its first parameter ([/ v1]) is less 2013than the second parameter ([/ v2]) according to the desired ordering.&] 2014[s3; &] 2015[s4; &] 2016[s5;:ArrayCtrl`:`:Sort`(int`,int`(`*`)`(const Value`&v1`,const Value`&v2`)`): [@(0.0.255) v 2017oid]_[* Sort]([@(0.0.255) int]_[*@3 ii], [@(0.0.255) int]_(`*[*@3 compare])([@(0.0.255) const 2018]_Value[@(0.0.255) `&]_v1, [@(0.0.255) const]_Value[@(0.0.255) `&]_v2)_`=_StdValueCompa 2019re)&] 2020[s2; Sorts the array rows according to the given ordering predicate 2021for the source index with a given ordinal number. When not explicitly 2022specified, the [* StdValueCompare] function is used as the default 2023comparison predicate.&] 2024[s7; [*C@3 ii]-|zero`-based ordinal number of the source index used 2025for sorting&] 2026[s7; [*C@3 compare]-|the sorting predicate function: the function is 2027supposed to return [* true] whenever its first parameter ([/ v1]) 2028is less than the second parameter ([/ v2]) according to the desired 2029ordering.&] 2030[s3; &] 2031[s4; &] 2032[s5;:ArrayCtrl`:`:Sort`(const Id`&`,int`(`*`)`(const Value`&v1`,const Value`&v2`)`): [@(0.0.255) v 2033oid]_[* Sort]([@(0.0.255) const ][_^Id^ Id]`&_[*@3 id], [@(0.0.255) int]_(`*[*@3 compare])([@(0.0.255) c 2034onst]_Value[@(0.0.255) `&]_v1, [@(0.0.255) const]_Value[@(0.0.255) `&]_v2)_`=_StdValueC 2035ompare)&] 2036[s2; Sorts the array rows according to the given ordering predicate 2037for the source index with a given identifier. When not explicitly 2038specified, the [* StdValueCompare] function is used as the default 2039comparison predicate.&] 2040[s7; [*C@3 id]-|identifier of the source index used for sorting&] 2041[s7; [*C@3 compare]-|the sorting predicate function: the function is 2042supposed to return [* true] whenever its first parameter ([/ v1]) 2043is less than the second parameter ([/ v2]) according to the desired 2044ordering .&] 2045[s3; &] 2046[s4; &] 2047[s5;:ArrayCtrl`:`:Sort`(`): [@(0.0.255) void]_[* Sort]()&] 2048[s2; Sorts the array according to the default ordering predicate 2049for the first source index. This is equivalent to calling [* Sort(0)].&] 2050[s3; &] 2051[s4; &] 2052[s5;:ArrayCtrl`:`:ColumnSort`(int`,Gate2`<int`,int`>`): [@(0.0.255) void]_[* ColumnSort]( 2053[@(0.0.255) int]_[*@3 column], [_^Gate2^ Gate2]<[@(0.0.255) int], [@(0.0.255) int]>_[*@3 orde 2054r])&] 2055[s2; Sorts by the column using ordering based on line indicies. This 2056is almost the same as the plain Sort, except that it respects 2057ColumnSortSecondary and ColumnSortFindKey flags.&] 2058[s3; &] 2059[s4; &] 2060[s5;:ArrayCtrl`:`:ColumnSort`(int`,const ValueOrder`&`): [@(0.0.255) void]_[* ColumnSort]( 2061[@(0.0.255) int]_[*@3 column], [@(0.0.255) const]_[_^ValueOrder^ ValueOrder][@(0.0.255) `&]_ 2062[*@3 order])&] 2063[s2; Sorts by the column. Note that this is different from Sort, 2064because the final converted value of column is used (which can 2065even be combination of more indexes).&] 2066[s3; &] 2067[s4;%- &] 2068[s5;:Upp`:`:ArrayCtrl`:`:ColumnSort`(int`,int`(`*`)`(const Valua`&a`,const Upp`:`:Value`&b`)`):%- [@(0.0.255) v 2069oid]_[* ColumnSort]([@(0.0.255) int]_[*@3 column], [@(0.0.255) int]_(`*[*@3 compare])([@(0.0.255) c 2070onst]_Valua[@(0.0.255) `&]_a, [@(0.0.255) const]_Value[@(0.0.255) `&]_b))&] 2071[s2; Sorts by the column. Note that this is different from Sort, 2072because the final converted value of column is used (which can 2073even be combination of more indexes).&] 2074[s3; &] 2075[s4; &] 2076[s5;:ArrayCtrl`:`:SetSortColumn`(int`,bool`): [@(0.0.255) void]_[* SetSortColumn]([@(0.0.255) i 2077nt]_[*@3 ii], [@(0.0.255) bool]_[*@3 descending]_`=_[@(0.0.255) false])&] 2078[s2; Sets the `"sorting`" column and calls DoColumnSort. This setting 2079is used by DoColumnSort.&] 2080[s3; &] 2081[s4; &] 2082[s5;:ArrayCtrl`:`:ToggleSortColumn`(int`): [@(0.0.255) void]_[* ToggleSortColumn]([@(0.0.255) i 2083nt]_[*@3 ii])&] 2084[s2; Similar to SetSortColumn, but if the column is already set, 2085descending flag is inverted; otherwise descending flag is set 2086to false (indicating ascending sort).&] 2087[s3; &] 2088[s4; &] 2089[s5;:ArrayCtrl`:`:DoColumnSort`(`): [@(0.0.255) void]_[* DoColumnSort]()&] 2090[s2; Sorts the array by sorting column and indicates it by setting 2091an image in the header.&] 2092[s3; &] 2093[s4; &] 2094[s5;:ArrayCtrl`:`:GetSortColumn`(`)const: [@(0.0.255) int]_[* GetSortColumn]()_[@(0.0.255) c 2095onst]&] 2096[s2; Returns the column that is sorting the ArrayCtrl (user clicked 2097on it and it has up or down arrow displayed).&] 2098[s3; &] 2099[s4; &] 2100[s5;:ArrayCtrl`:`:IsSortDescending`(`)const: [@(0.0.255) bool]_[* IsSortDescending]()_[@(0.0.255) c 2101onst]&] 2102[s2; Returns true if current column`-sort is descending.&] 2103[s3; &] 2104[s4; &] 2105[s5;:ArrayCtrl`:`:ClearCache`(`): [@(0.0.255) void]_[* ClearCache]()&] 2106[s2; Invalidates the whole [/ convert cache]. The convert cache keeps 2107the results of the [* Convert`::Format] method applied to individual 2108array data cells for performance reasons. Whenever you call the 2109[* ClearCache] method, all cache entries are marked as obsolete 2110and the [* Convert]`'s [* Format] method will be called as soon as 2111the converted value of a table cell is required (usually during 2112the next [* Paint]).&] 2113[s3; &] 2114[s4; &] 2115[s5;:ArrayCtrl`:`:InvalidateCache`(int`): [@(0.0.255) void]_[* InvalidateCache]([@(0.0.255) i 2116nt]_[*@3 i])&] 2117[s2; Invalidates a given row in the [/ convert cache]. For performance 2118reasons, the results of the [* Convert`::Format] method applied 2119to the individual data cells are kept in a cache. This function 2120marks a given row of the cache as obsolete; this means the next 2121time the converted values are to be used (usually within the 2122[* Paint] routine or when setting up the row editor controls), 2123the [* Convert] objects are used again to generate the actualized 2124output values.&] 2125[s7; [*C@3 i]-|zero`-based row index&] 2126[s3; &] 2127[s0; &] 2128[s0; [* Cursor and selection management]&] 2129[s3; &] 2130[s0; &] 2131[s5;:ArrayCtrl`:`:ScrollUp`(`): [@(0.0.255) void]_[* ScrollUp]()&] 2132[s5;:ArrayCtrl`:`:ScrollDown`(`): [@(0.0.255) void]_[* ScrollDown]()&] 2133[s5;:ArrayCtrl`:`:ScrollPageUp`(`): [@(0.0.255) void]_[* ScrollPageUp]()&] 2134[s5;:ArrayCtrl`:`:ScrollPageDown`(`): [@(0.0.255) void]_[* ScrollPageDown]()&] 2135[s5;:ArrayCtrl`:`:ScrollEnd`(`): [@(0.0.255) void]_[* ScrollEnd]()&] 2136[s5;:ArrayCtrl`:`:ScrollBegin`(`): [@(0.0.255) void]_[* ScrollBegin]()&] 2137[s2; Scrolls the content of ArrayCtrl.&] 2138[s3; &] 2139[s4; &] 2140[s5;:ArrayCtrl`:`:GetSelectCount`(`)const: [@(0.0.255) int]_[* GetSelectCount]()_[@(0.0.255) c 2141onst]&] 2142[s2; Returns the number of selected row within the table.&] 2143[s7; [*/ Return value]-|number of selected records (in the range [/ `[0 2144.. GetCount()`]])&] 2145[s3; &] 2146[s4; &] 2147[s5;:ArrayCtrl`:`:IsSelection`(`)const: [@(0.0.255) bool]_[* IsSelection]()_[@(0.0.255) con 2148st]&] 2149[s2; Checks whether any rows are selected. Equivalent to [* GetSelectCount() 2150> 0].&] 2151[s7; [*/ Return value]-|[* true] `= there is at least one selected row, 2152[* false] `= there is none.&] 2153[s3; &] 2154[s4; &] 2155[s5;:ArrayCtrl`:`:Select`(int`,bool`): [@(0.0.255) void]_[* Select]([@(0.0.255) int]_[*@3 i], 2156 [@(0.0.255) bool]_[*@3 sel]_`=_[@(0.0.255) true])&] 2157[s2; Selects / unselects a given row.&] 2158[s7; [*C@3 i]-|zero`-based row index&] 2159[s7; [*C@3 sel]-|[* true] `= add row to the current selection, [* false] 2160`= remove row from selection&] 2161[s3; &] 2162[s4; &] 2163[s5;:ArrayCtrl`:`:Select`(int`,int`,bool`): [@(0.0.255) void]_[* Select]([@(0.0.255) int]_[*@3 i 2164], [@(0.0.255) int]_[*@3 count], [@(0.0.255) bool]_[*@3 sel]_`=_[@(0.0.255) true])&] 2165[s2; Selects / unselects a given row range.&] 2166[s7; [*C@3 i]-|zero`-based index of the first row to select / unselect&] 2167[s7; [*C@3 count]-|number of rows to select / unselect&] 2168[s7; [*C@3 sel]-|[* true] `= select the rows, [* false] `= unselect the 2169rows&] 2170[s3; &] 2171[s4; &] 2172[s5;:ArrayCtrl`:`:IsSelected`(int`)const: [@(0.0.255) bool]_[* IsSelected]([@(0.0.255) int]_ 2173[*@3 i])_[@(0.0.255) const]&] 2174[s7; Checks whether a given row is selected.&] 2175[s3; &] 2176[s4; &] 2177[s5;:ArrayCtrl`:`:IsSel`(int`)const: [@(0.0.255) bool]_[* IsSel]([@(0.0.255) int]_[*@3 i])_[@(0.0.255) c 2178onst]&] 2179[s2; If there is selection in the widget, returns true if [*@3 i] is 2180selected, otherwise returns true if cursor is at [*@3 i].&] 2181[s3; &] 2182[s4;%- &] 2183[s5;:Upp`:`:ArrayCtrl`:`:GetSelKeys`(`)const:%- [_^Upp`:`:Vector^ Vector]<[@(0.0.255) int 2184]>_[* GetSelKeys]()_[@(0.0.255) const]&] 2185[s2; Returns keys (elements with index 0) of all selected lines (ordered 2186by line order).&] 2187[s3;%- &] 2188[s4; &] 2189[s5;:Upp`:`:ArrayCtrl`:`:EnableLine`(int`,bool`): [@(0.0.255) void]_[* EnableLine]([@(0.0.255) i 2190nt]_[*@3 i], [@(0.0.255) bool]_[*@3 e])&] 2191[s2; Enables line to be selected by cursor. Lines are enabled by 2192default.&] 2193[s3; &] 2194[s4; &] 2195[s5;:Upp`:`:ArrayCtrl`:`:DisableLine`(int`): [@(0.0.255) void]_[* DisableLine]([@(0.0.255) i 2196nt]_[*@3 i])&] 2197[s2; Same as EnableLine(false).&] 2198[s3; &] 2199[s4; &] 2200[s5;:Upp`:`:ArrayCtrl`:`:IsLineEnabled`(int`)const: [@(0.0.255) bool]_[* IsLineEnabled]([@(0.0.255) i 2201nt]_[*@3 i])_[@(0.0.255) const]&] 2202[s2; Returns true if line is enabled. Not that in addition to EnableLine 2203method, callback WhenLineEnabled affects the status too.&] 2204[s3; &] 2205[s4; &] 2206[s5;:Upp`:`:ArrayCtrl`:`:IsLineDisabled`(int`)const: [@(0.0.255) bool]_[* IsLineDisabled]( 2207[@(0.0.255) int]_[*@3 i])_[@(0.0.255) const]&] 2208[s2; Same as !IsLineEnabled([*@3 i]).&] 2209[s3; &] 2210[s4; &] 2211[s5;:Upp`:`:ArrayCtrl`:`:ShowLine`(int`,bool`): [@(0.0.255) void]_[* ShowLine]([@(0.0.255) i 2212nt]_[*@3 i], [@(0.0.255) bool]_[*@3 visible])&] 2213[s2; Sets the visibility of line. Hidden lines are omitted from the 2214list.&] 2215[s3; &] 2216[s4; &] 2217[s5;:Upp`:`:ArrayCtrl`:`:HideLine`(int`): [@(0.0.255) void]_[* HideLine]([@(0.0.255) int]_[*@3 i 2218])&] 2219[s2; Same as ShowLine([*@3 i], false).&] 2220[s3; &] 2221[s4; &] 2222[s5;:Upp`:`:ArrayCtrl`:`:IsLineVisible`(int`)const: [@(0.0.255) bool]_[* IsLineVisible]([@(0.0.255) i 2223nt]_[*@3 i])_[@(0.0.255) const]&] 2224[s2; Returns true if line is visible. Not that in addition to EnableLine 2225method, callback WhenLineVisible affects the visibility too.&] 2226[s3; &] 2227[s4; &] 2228[s5;:ArrayCtrl`:`:ClearSelection`(`): [@(0.0.255) void]_[* ClearSelection]()&] 2229[s2; Clears the current selection (unselects all selected rows).&] 2230[s3; &] 2231[s4; &] 2232[s5;:ArrayCtrl`:`:IsCursor`(`)const: [@(0.0.255) bool]_[* IsCursor]()_[@(0.0.255) const]&] 2233[s2; Checks whether the cursor is within the table. This is equivalent 2234to [* GetCursor()_>`=_0].&] 2235[s7; [*/ Return value]-|&] 2236[s3; &] 2237[s4; &] 2238[s5;:ArrayCtrl`:`:SetCursor`(int`): [@(0.0.255) bool]_[* SetCursor]([@(0.0.255) int]_[*@3 i]) 2239&] 2240[s2; Sets the current cursor row. When an array row is open for editing, 2241the function first commits the edited row, then moved the cursor 2242to the new row. When the edited row cannot be commited, the function 2243returns [* false] and doesn`'t change the cursor location.&] 2244[s7; [*C@3 i]-|zero`-based row index&] 2245[s7; [*/ Return value]-|[* true] `= cursor has been moved, [* false ]when 2246not (when committing the previously edited row failed)&] 2247[s3; &] 2248[s4; &] 2249[s5;:ArrayCtrl`:`:KillCursor`(`): [@(0.0.255) bool]_[* KillCursor]()&] 2250[s2; Moves the cursor away from the array. When an array row is open 2251for editing, the function first commits the edited row, then 2252moved the cursor away from the array. When the edited row cannot 2253be commited, the function returns [* false] and doesn`'t change 2254the cursor location.&] 2255[s7; [*/ Return value]-|[* true] `= cursor has been moved away from the 2256array, [* false] when not (when committing the previously edited 2257row failed)&] 2258[s3; &] 2259[s4; &] 2260[s5;:ArrayCtrl`:`:CancelCursor`(`): [@(0.0.255) void]_[* CancelCursor]()&] 2261[s2; Cancels editing of the row being currently edited. All changes 2262made in the individual column editors are rejected.&] 2263[s3; &] 2264[s4; &] 2265[s5;:ArrayCtrl`:`:GetCursor`(`)const: [@(0.0.255) int]_[* GetCursor]()_[@(0.0.255) const]&] 2266[s2; Returns the current cursor row, `-1 when none.&] 2267[s7; [*/ Return value]-|zero`-based cursor row index, `-1 `= cursor 2268is not in the array&] 2269[s3; &] 2270[s4; &] 2271[s5;:ArrayCtrl`:`:GoBegin`(`): [@(0.0.255) void]_[* GoBegin]()&] 2272[s2; Moves the cursor to the first row in the array (equivalent to 2273[* SetCursor(0)]).&] 2274[s3; &] 2275[s4; &] 2276[s5;:ArrayCtrl`:`:GoEnd`(`): [@(0.0.255) void]_[* GoEnd]()&] 2277[s2; Moves the cursor to the last array row (equivalent to [* SetCursor(GetCount() 2278`- 1)]).&] 2279[s3; &] 2280[s4; &] 2281[s5;:ArrayCtrl`:`:GetCursorSc`(`)const: [@(0.0.255) int]_[* GetCursorSc]()_[@(0.0.255) cons 2282t]&] 2283[s2; Returns the visual vertical position of the cursor row relative 2284to the current view. This method, in combination with [* ScCursor], 2285can be used to reposition the cursor row while maintaining the 2286same visual position of the row within the array view.&] 2287[s7; [*/ Return value]-|an integer describing the vertical position 2288of the cursor row relative to the array view&] 2289[s3; &] 2290[s4; &] 2291[s5;:ArrayCtrl`:`:ScCursor`(int`): [@(0.0.255) void]_[* ScCursor]([@(0.0.255) int]_[*@3 a])&] 2292[s2; Modifies the scrollbar position so that the current cursor row 2293appears at a given vertical position relative to the array view. 2294By doing the following sequence of operations: [* GetCursorSc], 2295then reposition the cursor row, then [* ScCursor], you can achieve 2296cursor relocation while maintaining its visual location within 2297the array view.&] 2298[s7; [*C@3 a]-|an integer describing the vertical position of the cursor 2299row (typically a number returned by a previous call to [* GetCursorSc])&] 2300[s3; &] 2301[s4; &] 2302[s5;:ArrayCtrl`:`:CenterCursor`(`): [@(0.0.255) void]_[* CenterCursor]()&] 2303[s2; Modifies the scrollbar position so that the current cursor row 2304appears in the middle of the array view.&] 2305[s3; &] 2306[s4; &] 2307[s5;:ArrayCtrl`:`:ScrollInto`(int`): [@(0.0.255) void]_[* ScrollInto]([@(0.0.255) int]_[*@3 l 2308ine])&] 2309[s2; Moves the scrollbar by the least possible amount in order to 2310make the given array row visible. When the given array row is 2311already visible, the function does nothing.&] 2312[s7; [*C@3 line]-|zero`-based row index of the array row to make visible&] 2313[s3; &] 2314[s4; &] 2315[s5;:ArrayCtrl`:`:ScrollIntoCursor`(`): [@(0.0.255) void]_[* ScrollIntoCursor]()&] 2316[s2; Moves the scrollbar by the least possible amount in order to 2317make the cursor row visible. This is equivalent to [* ScrollInto(GetCursor())].&] 2318[s3; &] 2319[s4; &] 2320[s5;:ArrayCtrl`:`:GetCursor`(`)const: [@(0.0.255) int]_[* GetCursor]()_[@(0.0.255) const]&] 2321[s2; Returns the current vertical scrollbar position.&] 2322[s7; [*/ Return value]-|Pixel position of the vertical scrollbar. Position 23230 is at the very top (the top row of the array is fully visible).&] 2324[s3; &] 2325[s4; &] 2326[s5;:ArrayCtrl`:`:ScrollTo`(int`): [@(0.0.255) void]_[* ScrollTo]([@(0.0.255) int]_[*@3 sc])&] 2327[s2; Moves the vertical array scrollbar to a given position.&] 2328[s7; [*C@3 sc]-|Pixel position of the scrollbar. The visible portion 2329of the array can be obtained conceptually by taking the stack 2330of array rows with its top aligned at the top of the view and 2331moving it [/ sc] pixels upwards.&] 2332[s3; &] 2333[s4; &] 2334[s5;:ArrayCtrl`:`:Find`(const Value`&`,int`,int`)const: [@(0.0.255) int]_[* Find]([@(0.0.255) c 2335onst]_[_^Value^ Value][@(0.0.255) `&]_[*@3 v], [@(0.0.255) int]_[*@3 ii]_`=_[@3 0], 2336[@(0.0.255) int]_[*@3 from]_`=_[@3 0])_[@(0.0.255) const]&] 2337[s2; [*C@3 v]-|value to look for in the given source index&] 2338[s7; [*C@3 ii]-|zero`-based ordinal number of the source index to search&] 2339[s7; [*C@3 from]-|zero`-based row index to start the search from&] 2340[s7; [*/ Return value]-|zero`-based number of the matched row, `-1 when 2341none&] 2342[s3; &] 2343[s4; &] 2344[s5;:ArrayCtrl`:`:Find`(const Value`&`,const Id`&`,int`)const: [@(0.0.255) int]_[* Find]( 2345[@(0.0.255) const]_[_^Value^ Value][@(0.0.255) `&]_[*@3 v], [@(0.0.255) const 2346][_^Id^ Id]`&_[*@3 id], [@(0.0.255) int]_[*@3 from]_`=_[@3 0])_[@(0.0.255) const]&] 2347[s2; Locates the row (using linear search beginning at the row [/ from]) 2348in which the source index value identified by [/ id] equals [/ val]. 2349If such a row is found, the function returns its zero`-based 2350index. When not matched, the function returns `-1.&] 2351[s7; [*C@3 v]-|value to look for in the given source index&] 2352[s7; [*C@3 id]-|source index identifier&] 2353[s7; [*C@3 from]-|zero`-based row index to start the search from&] 2354[s7; [*/ Return value]-|zero`-based number of the matched row, `-1 when 2355none&] 2356[s3; &] 2357[s4; &] 2358[s5;:ArrayCtrl`:`:FindSetCursor`(const Value`&`,int`,int`): [@(0.0.255) bool]_[* FindSetC 2359ursor]([@(0.0.255) const]_[_^Value^ Value][@(0.0.255) `&]_[*@3 val], 2360[@(0.0.255) int]_[*@3 ii]_`=_[@3 0], [@(0.0.255) int]_[*@3 from]_`=_[@3 0])&] 2361[s2; Locates the row (using linear search beginning at the row [/ from]) 2362in which the source index value identified by its ordinal number 2363[/ ii] equals [/ val]. If such a row is found, the [* SetCursor] is 2364called automatically to move the cursor to such a row.&] 2365[s7; [*C@3 val]-|value to look for in the given source index&] 2366[s7; [*C@3 ii]-|zero`-based ordinal number of the source index to search&] 2367[s7; [*C@3 from]-|zero`-based row index to start the search from&] 2368[s7; [*/ Return value]-|zero`-based number of the matched row, `-1 when 2369none&] 2370[s3; &] 2371[s4; &] 2372[s5;:ArrayCtrl`:`:FindSetCursor`(const Value`&`,const Id`&`,int`): [@(0.0.255) bool]_[* F 2373indSetCursor]([@(0.0.255) const]_[_^Value^ Value][@(0.0.255) `&]_[*@3 val], 2374[@(0.0.255) const ][_^Id^ Id]`&_[*@3 id], [@(0.0.255) int]_[*@3 from]_`=_[@3 0])&] 2375[s2; Locates the row (using linear search beginning at the row [/ from]) 2376in which the source index value identified by [/ id] equals [/ val]. 2377If such a row is found, the [* SetCursor] is called automatically 2378to move the cursor to such a row.&] 2379[s7; [*C@3 val]-|value to look for in the given source index&] 2380[s7; [*C@3 id]-|source index identifier&] 2381[s7; [*C@3 from]-|zero`-based row index to start the search from&] 2382[s7; [*/ Return value]-|[* true] `= the desired row was found (and the 2383cursor set), [* false] when not&] 2384[s3; &] 2385[s0;* &] 2386[s0; [* User interface elements]&] 2387[s3; &] 2388[s0; &] 2389[s5;:ArrayCtrl`:`:StdBar`(Bar`&`): [@(0.0.255) void]_[* StdBar]([_^Bar^ Bar][@(0.0.255) `&]_[*@3 m 2390enu])&] 2391[s2; The default array local menu. The default local menu consists 2392of the standard editing actions (inserting / appending / duplicating 2393a row, editing a row, removing a row, moving a row, select all 2394rows) filtered by the array properties enabling / disabling the 2395various GUI elements (item insertion / deletion etc.). &] 2396[s7; [*C@3 menu]-|the [* Bar] object representing the menu being generated&] 2397[s3; &] 2398[s4; &] 2399[s5;:ArrayCtrl`:`:IsModified`(int`)const: [@(0.0.255) bool]_[* IsModified]([@(0.0.255) int]_ 2400[*@3 ii])_[@(0.0.255) const]&] 2401[s2; Checks a source index in the currently edited row for changes.&] 2402[s7; [*C@3 ii]-|zero`-based row index&] 2403[s7; [*/ Return value]-|[* true] `= the index has been modified, [* false] 2404`= the index is in its original state&] 2405[s3; &] 2406[s4; &] 2407[s5;:ArrayCtrl`:`:IsModified`(const Id`&`)const: [@(0.0.255) bool]_[* IsModified]([@(0.0.255) c 2408onst ][_^Id^ Id]`&_[*@3 id])_[@(0.0.255) const]&] 2409[s2; Checks a source index in the currently edited array row for 2410changes.&] 2411[s7; [*C@3 id]-|source index identifier&] 2412[s7; [*/ Return value]-|[* true] `= the source index has been modified, 2413[* false ]when not&] 2414[s3; &] 2415[s4; &] 2416[s5;:ArrayCtrl`:`:StartEdit`(int`): [@(0.0.255) bool]_[* StartEdit]([@(0.0.255) int]_[*@3 d]_ 2417`=_[@3 0])&] 2418[s2; Opens the current cursor row for editing and sets focus to the 2419[/ d]`-th column.&] 2420[s7; [*C@3 d]-|zero`-based column index&] 2421[s7; [*/ Return value]-|[* true] `= editing successfully initiated, [* false] 2422when not (when the array is in [* ReadOnly] mode or it has no editable 2423columns)&] 2424[s3; &] 2425[s4; &] 2426[s5;:ArrayCtrl`:`:GetEditColumn`(`)const: [@(0.0.255) int]_[* GetEditColumn]()_[@(0.0.255) c 2427onst]&] 2428[s2; Returns the column being currently edited.&] 2429[s7; [*/ Return value]-|zero`-based index of the column being edited, 2430`-1 `= none&] 2431[s3; &] 2432[s4; &] 2433[s5;:ArrayCtrl`:`:DoEdit`(`): [@(0.0.255) void]_[* DoEdit]()&] 2434[s2; Opens the current cursor row for editing.&] 2435[s3; &] 2436[s4; &] 2437[s5;:ArrayCtrl`:`:DoInsert`(int`): [@(0.0.255) void]_[* DoInsert]([@(0.0.255) int]_[*@3 curso 2438r])&] 2439[s2; Begins the GUI insertion of a new row at a given location.&] 2440[s7; [*C@3 cursor]-|zero`-based location of the new row&] 2441[s3; &] 2442[s4; &] 2443[s5;:ArrayCtrl`:`:DoInsertBefore`(`): [@(0.0.255) void]_[* DoInsertBefore]()&] 2444[s2; Begins the GUI insertion of a new row above the current row.&] 2445[s3; &] 2446[s4; &] 2447[s5;:ArrayCtrl`:`:DoInsertAfter`(`): [@(0.0.255) void]_[* DoInsertAfter]()&] 2448[s2; Begins the GUI insertion of a new row below the current row.&] 2449[s3; &] 2450[s4; &] 2451[s5;:ArrayCtrl`:`:DoAppend`(`): [@(0.0.255) void]_[* DoAppend]()&] 2452[s2; Begins the GUI insertion of a new row at the end of the array.&] 2453[s3; &] 2454[s4; &] 2455[s5;:ArrayCtrl`:`:DoRemove`(`): [@(0.0.255) virtual] [@(0.0.255) bool]_[* DoRemove]()&] 2456[s2; Performs the GUI`-based removal of the current cursor row. When 2457the [* AskRemove] property is set to [* true] and the user cancels 2458the confirmation dialog, the function returns [* false] and the 2459current row is not removed.&] 2460[s7; [*/ Return value]-|[* true] `= row has been removed successfully, 2461[* false] `= user has canceled the row removal&] 2462[s3; &] 2463[s4; &] 2464[s5;:ArrayCtrl`:`:DoDuplicate`(`): [@(0.0.255) void]_[* DoDuplicate]()&] 2465[s2; Duplicates the current row and opens it for editing.&] 2466[s3; &] 2467[s4; &] 2468[s5;:ArrayCtrl`:`:DoSelectAll`(`): [@(0.0.255) void]_[* DoSelectAll]()&] 2469[s2; Marks all array row as selected.&] 2470[s3; &] 2471[s4; &] 2472[s5;:ArrayCtrl`:`:AcceptEnter`(`): [@(0.0.255) bool]_[* AcceptEnter]()&] 2473[s2; Performs all necessary GUI actions equivalent to when the user 2474presses the [* Enter] key. The row being currently edited is committed 2475and, in the case it was a newly appended line and the [* NoInsertAppend] 2476property is not set, an additional row is added to the array 2477and opened for editing.&] 2478[s7; [*/ Return value]-|[* true] `= the current row has been successfully 2479committed, [* false] when not&] 2480[s3; &] 2481[s0; &] 2482[s0; &] 2483[s0; [* Content export]&] 2484[s0;* &] 2485[s3; &] 2486[s5;:ArrayCtrl`:`:AsText`(String`(`*`)`(const Value`&`)`,bool`,const char`*`,const char`*`,const char`*`,const char`*`)const: [_^String^ S 2487tring]_[* AsText]([_^String^ String]_(`*[*@3 format])([@(0.0.255) const]_Value[@(0.0.255) `& 2488]), [@(0.0.255) bool]_[*@3 sel]_`=_[@(0.0.255) false], [@(0.0.255) const]_[@(0.0.255) char]_ 2489`*[*@3 tab]_`=_`"`\t`", [@(0.0.255) const]_[@(0.0.255) char]_`*[*@3 row]_`=_`"`\r`\n`", 2490[@(0.0.255) const]_[@(0.0.255) char]_`*[*@3 hdrtab]_`=_`"`\t`", [@(0.0.255) const]_[@(0.0.255) c 2491har]_`*[*@3 hdrrow]_`=_`"`\r`\n`")_[@(0.0.255) const]&] 2492[s2; Generic function for conversion of ArrayCtrl content to text. 2493The content visible on screen is exported (means, it exports 2494columns defined using AddColumn, not indicies). Cells are converted 2495to output format using [*@3 format] function. If [*@3 sel] is true, 2496only rows with IsSel true are exported. [*@3 tab] represents a 2497separator text between cells in a row, [*@3 row] separator of rows. 2498[*@3 hdrtab] is separator of header cells (those are texts of ArrayCtrl 2499header) `- if NULL, no header is exported. [*@3 hdrrow].is separator 2500of header and data rows.&] 2501[s3; &] 2502[s4; &] 2503[s5;:ArrayCtrl`:`:SetClipboard`(bool`,bool`)const: [@(0.0.255) void]_[* SetClipboard]([@(0.0.255) b 2504ool]_[*@3 sel]_`=_[@(0.0.255) false], [@(0.0.255) bool]_[*@3 hdr]_`=_[@(0.0.255) true])_[@(0.0.255) c 2505onst]&] 2506[s2; Puts ArrayCtrl content to clipboard in text format, `"`\t`" 2507and `"`\r`\n`" as separators. If [*@3 sel] is true, only rows with 2508IsSel true are exported, [*@3 hdr] controls whether header is exported.&] 2509[s3; &] 2510[s4; &] 2511[s5;:ArrayCtrl`:`:AsQtf`(bool`,bool`): [_^String^ String]_[* AsQtf]([@(0.0.255) bool]_[*@3 se 2512l]_`=_[@(0.0.255) false], [@(0.0.255) bool]_[*@3 hdr]_`=_[@(0.0.255) true])&] 2513[s2; Returns ArrayCtrl content in QTF format. If [*@3 sel] is true, 2514only rows with IsSel true are exported, [*@3 hdr] controls whether 2515header is exported.&] 2516[s3; &] 2517[s4; &] 2518[s5;:ArrayCtrl`:`:AsCsv`(bool`,int`,bool`): [_^String^ String]_[* AsCsv]([@(0.0.255) bool]_ 2519[*@3 sel]_`=_[@(0.0.255) false], [@(0.0.255) int]_[*@3 sep]_`=_`';`', 2520[@(0.0.255) bool]_[*@3 hdr]_`=_[@(0.0.255) true])&] 2521[s2; Returns ArrayCtrl content in csv format, using [*@3 sep] as separator. 2522If [*@3 sel] is true, only rows with IsSel true are exported, [*@3 hdr] 2523controls whether header is exported.&] 2524[s0; &] 2525[s0; &] 2526[s0; [* Notification callbacks]&] 2527[s3; &] 2528[s3; &] 2529[s5;:ArrayCtrl`:`:WhenSel: [_^Callback^ Callback]_[* WhenSel]&] 2530[s2; Called whenever cursor or selection changes. This probably the 2531most common ArrayCtrl callback. We recommend to start with this 2532one first and use others only if necessary.&] 2533[s3; &] 2534[s4; &] 2535[s5;:ArrayCtrl`:`:WhenLeftClick: [_^Callback^ Callback]_[* WhenLeftClick]&] 2536[s2; This callback is called whenever the user clicks an array cell.&] 2537[s3; &] 2538[s4; &] 2539[s5;:ArrayCtrl`:`:WhenLeftDouble: [_^Callback^ Callback]_[* WhenLeftDouble]&] 2540[s2; This callback is called whenever the user doubleclicks an array 2541cell.&] 2542[s3; &] 2543[s4; &] 2544[s5;:ArrayCtrl`:`:WhenMouseMove: [_^Callback1^ Callback1]<[_^Point^ Point]>_[* WhenMouseMov 2545e]&] 2546[s2; Called when mouse moves over the ArrayCtrl or moves out of ArrayCtrl. 2547The Point`::y is the line number, Point`::x column index. If mouse 2548moves out of ArrayCtrl, parameter is Null.&] 2549[s3; &] 2550[s4; &] 2551[s5;:ArrayCtrl`:`:WhenEnterKey: [_^Callback^ Callback]_[* WhenEnterKey]&] 2552[s2; Called when user presses Enter key while focus is in ArrayCtrl, 2553some line of ArrayCtrl has cursor and Enter key is not `'eaten`' 2554by another action like accepting the input. When this Callback 2555is not empty, Enter key is never passed to parent.&] 2556[s3; &] 2557[s4; &] 2558[s5;:ArrayCtrl`:`:WhenBar: [_^Callback1^ Callback1]<Bar[@(0.0.255) `&]>_[* WhenBar]&] 2559[s2; This callback is called whenever the local array menu has to 2560be regenerated. By setting this callback to a different function 2561/ method you can supply a custom local menu for the array. The 2562[* Bar`&] argument is a reference to the menu to be generated.&] 2563[s3; &] 2564[s4; &] 2565[s5;:ArrayCtrl`:`:WhenEnterRow: [_^Callback^ Callback]_[* WhenEnterRow]&] 2566[s0; [* -|][*/ Deprecated]&] 2567[s2; This callback is called every time the cursor location changes 2568to a different row of the array.&] 2569[s3; &] 2570[s4; &] 2571[s5;:ArrayCtrl`:`:WhenAcceptRow: [_^Gate^ Gate]_[* WhenAcceptRow]&] 2572[s2; This gate is called every time an array row (open for editing) 2573needs to be validated. When the gate returns [* false], the validation 2574process is assumed to have failed, when it returns [* true], it 2575is assumed to have succeeded. You can use this callback to add 2576your own validation algorithms relevant to the array context 2577within your application.&] 2578[s3; &] 2579[s4; &] 2580[s5;:ArrayCtrl`:`:WhenUpdateRow: [_^Callback^ Callback]_[* WhenUpdateRow]&] 2581[s2; This callback is called whenever an array row has been updated. 2582You can use this callback e.g. to project the changes to a database 2583or generally to an external data source.&] 2584[s3; &] 2585[s4; &] 2586[s5;:ArrayCtrl`:`:WhenKillCursor: [_^Callback^ Callback]_[* WhenKillCursor]&] 2587[s0; [* -|][*/ Deprecated]&] 2588[s2; This callback is called whenever the cursor is moved away from 2589the table.&] 2590[s2; [* Note:] internally, when moving the cursor (e.g. by calling the 2591[* SetCursor ]method), after committing the previous row the cursor 2592is removed from the table using [* KillCursor] and placed to the 2593new location afterwards. Therefore every time the cursor is moved, 2594the [* WhenKillCursor] callback is called as a by`-product.&] 2595[s3; &] 2596[s4; &] 2597[s5;:ArrayCtrl`:`:WhenCursor: [_^Callback^ Callback]_[* WhenCursor]&] 2598[s0; [* -|][*/ Deprecated]&] 2599[s2; This callback is called every time the cursor row number changes 2600(either when the cursor is removed from the table, or when it 2601has been moved to a different row).&] 2602[s3; &] 2603[s4; &] 2604[s5;:ArrayCtrl`:`:WhenArrayAction: [_^Callback^ Callback]_[* WhenArrayAction]&] 2605[s2; This callback is called every time the source array data changes 2606(typically after accepting changes to a certain row or after 2607deleting a row).&] 2608[s3; &] 2609[s4; &] 2610[s5;:ArrayCtrl`:`:WhenStartEdit: [_^Callback^ Callback]_[* WhenStartEdit]&] 2611[s2; This callback is called whenever the array row editing process 2612is initiated. It can be used e.g. to set up some additional properties 2613of the column editor objects, to fill in drop`-down lists pertaining 2614to certain column editors etc.&] 2615[s3; &] 2616[s4; &] 2617[s5;:ArrayCtrl`:`:WhenAcceptEdit: [_^Callback^ Callback]_[* WhenAcceptEdit]&] 2618[s2; This callback is called whenever the currently edited line has 2619been committed.&] 2620[s3; &] 2621[s4; &] 2622[s5;:ArrayCtrl`:`:WhenSelection: [_^Callback^ Callback]_[* WhenSelection]&] 2623[s0; [* -|][*/ Deprecated]&] 2624[s2; This callback is called whenever the current array selection 2625changes. This includes changes to the cursor location as the 2626cursor is automatically considered part of the selection.&] 2627[s3; &] 2628[s4; &] 2629[s5;:ArrayCtrl`:`:WhenCtrlsAction: [_^Callback^ Callback]_[* WhenCtrlsAction]&] 2630[s2; This callback is called whenever some of the editor controls 2631constructed automatically via the column editing [/ factory] calls 2632its [* WhenAction] method. It can be used to watch out for changes 2633in the cell editors and react to specific situations accordingly.&] 2634[s3; &] 2635[s4; &] 2636[s5;:ArrayCtrl`:`:WhenScroll: [_^Callback^ Callback]_[* WhenScroll]&] 2637[s2; Called when scrolling of ArrayCtrl content happened.&] 2638[s3; &] 2639[s3; &] 2640[s4; &] 2641[s5;:ArrayCtrl`:`:WhenHeaderLayout: [_^Callback^ Callback]_[* WhenHeaderLayout]&] 2642[s2; Called when header changes.&] 2643[s3; &] 2644[s4;%- &] 2645[s5;:Upp`:`:ArrayCtrl`:`:WhenColumnSorted:%- [_^Upp`:`:Event^ Event]<>_[* WhenColumnSorte 2646d]&] 2647[s2; Invoked at the end of DoColumnSort. This allows to react to 2648user sorting ArrayCtrl by clicking on column header marked as 2649Sorting.&] 2650[s3;%- &] 2651[s4; &] 2652[s5;:ArrayCtrl`:`:WhenLineEnabled: [_^Callback2^ Callback2]<[@(0.0.255) int], 2653[@(0.0.255) bool`&]>_[* WhenLineEnabled]&] 2654[s2; Provides additional means to enable/disable lines in addition 2655to `"EnableLine`" interface. This is especially useful when using 2656SetVirtualCount. First parameter is the line number, second is 2657reference to enable status.&] 2658[s3; &] 2659[s4; &] 2660[s5;:Upp`:`:ArrayCtrl`:`:WhenLineVisible: [_^Upp`:`:Callback2^ Callback2]<[@(0.0.255) int 2661], [@(0.0.255) bool`&]>_[* WhenLineVisible]&] 2662[s2; Provides additional means to show/hide lines in addition to 2663`"ShowLine`" interface. This is especially useful when using 2664SetVirtualCount. First parameter is the line number, second is 2665reference to visibility status.&] 2666[s3; &] 2667[s0; &] 2668[ {{10000t/25b/25@3 [s0; [*@(229)4 ArrayCtrl`::IdInfo]]}}&] 2669[s3; &] 2670[s1;:ArrayCtrl`:`:IdInfo`:`:struct: [@(0.0.255)3 struct][3 _][*3 IdInfo]&] 2671[s9; The [* IdInfo] structure contains properties of all source array 2672indices. It can be used to set additional properties pertaining 2673to source array data.&] 2674[s3; &] 2675[s0; &] 2676[ {{10000F(128)G(128)@1 [s0; [* Public Member List]]}}&] 2677[s3; &] 2678[s5;:ArrayCtrl`:`:IdInfo`:`:InsertValue`(const Value`&`): [_^ArrayCtrl`:`:IdInfo^ IdInf 2679o][@(0.0.255) `&]_[* InsertValue]([@(0.0.255) const]_[_^Value^ Value][@(0.0.255) `&]_[*@3 v]) 2680&] 2681[s2; The method sets up the default source index value for newly 2682created rows. This is used only when the row insertion is GUI`-based 2683(like using the [* DoInsert] method for instance). When a row is 2684added to the array programmatically (e.g. using [* Add] or [* Insert]), 2685these default values are not used.&] 2686[s7; [*C@3 v]-|default source index value&] 2687[s7; [*/ Return value]-|[* `*this]&] 2688[s3; &] 2689[s4; &] 2690[s5;:ArrayCtrl`:`:IdInfo`:`:InsertValue`(ValueGen`&`): [_^ArrayCtrl`:`:IdInfo^ IdInfo][@(0.0.255) `& 2691]_[* InsertValue]([_^ValueGen^ ValueGen][@(0.0.255) `&]_[*@3 g])&] 2692[s2; The method sets up a factory for generating default index values 2693for newly created rows. This is used only when the row insertion 2694is GUI`-based (like using the [* DoInsert] method for instance). 2695When a row is added to the array programmatically (e.g. using 2696[* Add] or [* Insert]), the [* InserValue] property is not consulted.&] 2697[s7; [*C@3 g]-|a reference to the value generation factory. The ownership 2698to the factory is not passed by this call; the caller must insure 2699the existence of the factory object throughout the array duration.&] 2700[s7; [*/ Return value]-|[* `*this]&] 2701[s3; &] 2702[s4; &] 2703[s5;:ArrayCtrl`:`:IdInfo`:`:Accel`(int`(`*`)`(int`)`): [_^ArrayCtrl`:`:IdInfo^ IdInfo][@(0.0.255) `& 2704]_[* Accel]([@(0.0.255) int]_(`*[*@3 filter])([@(0.0.255) int]))&] 2705[s2; This method sets up the source index accelerator function. The 2706accelerator is used to quickly locate rows using the keyboard 2707key presses.&] 2708[s7; [*C@3 filter]-|a [* CharFilter ]function for keypress filtering&] 2709[s7; [*/ Return value]-|[* `*this]&] 2710[s3; &] 2711[s4; &] 2712[s5;:ArrayCtrl`:`:IdInfo`:`:Accel`(`): [_^ArrayCtrl`:`:IdInfo^ IdInfo][@(0.0.255) `&]_[* Ac 2713cel]()&] 2714[s2; This method sets up keyboard acceleration for the given source 2715index. The `'trivial`' [/ CharConvert] is used for character translation.&] 2716[s7; [*/ Return value]-|[* `*this]&] 2717[s3; &] 2718[s4; &] 2719[s5;:ArrayCtrl`:`:IdInfo`:`:GetInsertValue`(`): [_^Value^ Value]_[* GetInsertValue]()&] 2720[s2; Uses the [* InsertValue] property to generate a new source index 2721value (either using a fixed default value or the value creation 2722factory).&] 2723[s7; [*/ Return value]-|the generated value to be used as the default 2724for the newly inserted row.&] 2725[s3; &] 2726[s0; &] 2727[s0; &] 2728[s0; &] 2729[ {{10000t/25b/25@3 [s0; [*@(229)4 ArrayCtrl`::Column]]}}&] 2730[s3; &] 2731[s1;:ArrayCtrl`:`:Column`:`:class: [@(0.0.255)3 class][3 _][*3 Column][3 _:_][@(0.0.255)3 privat 2732e][3 _][*@3;3 FormatConvert]&] 2733[s2; &] 2734[s0; [/ Derived from] FormatConvert&] 2735[s0;3 &] 2736[s0; The [* ArrayCtrl`::Column] structure describes an output array 2737column. Its methods can be used to set or query its properties, 2738some of which are also settable via ArrayCtrl methods.&] 2739[s3; &] 2740[s0; &] 2741[ {{10000F(128)G(128)@1 [s0; [* Public Member List]]}}&] 2742[s3; &] 2743[s5;:ArrayCtrl`:`:Column`:`:Add`(int`): [_^ArrayCtrl`:`:Column^ Column][@(0.0.255) `&]_[* A 2744dd]([@(0.0.255) int]_[*@3 `_pos])&] 2745[s2; Adds another source data index to the list of source indices 2746used as the data for the given output column.&] 2747[s7; [*C@3 `_pos]-|zero`-based ordinal number of the source index&] 2748[s7; [*/ Return value]-|[* `*this].&] 2749[s3; &] 2750[s4; &] 2751[s5;:ArrayCtrl`:`:Column`:`:Add`(const Id`&`): [_^ArrayCtrl`:`:Column^ Column][@(0.0.255) `& 2752]_[* Add](const [_^Id^ Id]`&_[*@3 id])&] 2753[s2; Adds another source data index to the list of source indices 2754used as the data for the given output column.&] 2755[s7; [*C@3 id]-|the [* Id] identifier of the source index&] 2756[s7; [*/ Return value]-|[* `*this]&] 2757[s3; &] 2758[s3; &] 2759[s4; &] 2760[s5;:ArrayCtrl`:`:Column`:`:AddIndex`(const Id`&`): [_^ArrayCtrl`:`:Column^ Column][@(0.0.255) `& 2761]_[* AddIndex]([@(0.0.255) const]_[_^Id^ Id][@(0.0.255) `&]_[*@3 id])&] 2762[s2; Adds another source index to the array and adds it to the list 2763of source indices bound to this output column. The newly created 2764index is assigned the given identifier.&] 2765[s7; [*C@3 id]-|the identifier for the newly created index&] 2766[s7; [*/ Return value]-|[* `*this]&] 2767[s3; &] 2768[s4; &] 2769[s5;:ArrayCtrl`:`:Column`:`:AddIndex`(`): [_^ArrayCtrl`:`:Column^ Column][@(0.0.255) `&]_ 2770[* AddIndex]()&] 2771[s2; Adds another source index to the array and adds it to the list 2772of source indices bound to this output column.&] 2773[s7; [*/ Return value]-|[* `*this]&] 2774[s3; &] 2775[s4; &] 2776[s5;:ArrayCtrl`:`:Column`:`:SetConvert`(const Convert`&`): [_^ArrayCtrl`:`:Column^ Colu 2777mn][@(0.0.255) `&]_[* SetConvert]([@(0.0.255) const]_[_^Convert^ Convert][@(0.0.255) `&]_[*@3 c 2778])&] 2779[s2; Sets the [* Convert] object for the given column. This object 2780is used to convert the source values (obtained from the source 2781data matrix) to the values displayable and/or editable by the 2782respective column display / editor object.&] 2783[s2; [* Note:] the ownership of the [* Convert] object is not transferred 2784by this function. The array merely stores a pointer to the Convert 2785object. It is up to the host application to keep the Convert 2786object alive as long as necessary (until the ArrayCtrl object 2787is destroyed or all references to the Convert object obliterated 2788by new calls to the [* SetConvert] method). In any case, most Convert`-based 2789object do not support copying at all; moreover, as the Convert`-based 2790objects are mostly derived from the basic class, their copying 2791is normally prone to slicing.&] 2792[s7; [*C@3 c]-|a constant reference to the Convert object to use for 2793the given column&] 2794[s7; [*/ Return value]-|[* `*this]&] 2795[s3; &] 2796[s4;%- &] 2797[s5;:Upp`:`:ArrayCtrl`:`:Column`:`:ConvertBy`(Upp`:`:Function`<Upp`:`:Value`(const Upp`:`:Value`&`)`>`):%- [_^Upp`:`:ArrayCtrl`:`:Column^ A 2798rrayCtrl`::Column][@(0.0.255) `&]_[* ConvertBy]([_^Upp`:`:Function^ Function]<Value([@(0.0.255) c 2799onst]_Value[@(0.0.255) `&])>_[*@3 cv])&] 2800[s2; Similar to SetConvert, but using [%-*@3 cv] instead of class for 2801conversion.&] 2802[s3; &] 2803[s4; &] 2804[s5;:ArrayCtrl`:`:Column`:`:SetFormat`(const char`*`): [@(0.0.255) virtual] 2805[_^ArrayCtrl`:`:Column^ Column][@(0.0.255) `&]_[* SetFormat]([@(0.0.255) const]_[@(0.0.255) c 2806har]_`*[*@3 fmt])&] 2807[s2; Sets the format string to use for the default value formatting. 2808When no Convert object is set for the column, the source value 2809is normally passed to the [* NFormat] function where the [/ fmt] 2810argument defines the desired formatting pattern.&] 2811[s7; [*C@3 fmt]-|a [* NFormat]`-compatible formatting pattern&] 2812[s7; [*/ Return value]-|[* `*this]&] 2813[s3; &] 2814[s4; &] 2815[s5;:ArrayCtrl`:`:Column`:`:SetDisplay`(const Display`&`): [_^ArrayCtrl`:`:Column^ Colu 2816mn][@(0.0.255) `&]_[* SetDisplay]([@(0.0.255) const]_[_^Display^ Display][@(0.0.255) `&]_[*@3 d 2817])&] 2818[s2; Sets the default Display to use for this column. The column 2819Display can be overridden for certain array cells by calls to 2820the [*^topic`:`/`/CtrlLib`/src`/ArrayCtrl`$en`-us`#`:`:ArrayCtrl`:`:SetDisplay`(int`,int`,const Display`&`)^ A 2821rrayCtrl`::SetDisplay] method.&] 2822[s2; [* Note:] the ownership to the Display object is not transferred 2823by this function. The array merely stores a pointer to the Display; 2824it is up to the host application to keep the Display object alive 2825as long as necessary.&] 2826[s7; [*C@3 d]-|a reference to the Display object&] 2827[s7; [*/ Return value]-|[* `*this]&] 2828[s3; &] 2829[s4; &] 2830[s5;:ArrayCtrl`:`:Column`:`:Edit`(Ctrl`&`): [_^ArrayCtrl`:`:Column^ Column][@(0.0.255) `& 2831]_[* Edit]([_^Ctrl^ Ctrl][@(0.0.255) `&]_[*@3 e])&] 2832[s2; Sets up the Ctrl`-based object to use for inline array column 2833editing.&] 2834[s7; [*C@3 e]-|a reference to the editor control object&] 2835[s7; [*/ Return value]-|[* `*this]&] 2836[s3; &] 2837[s4; &] 2838[s5;:ArrayCtrl`:`:Column`:`:Ctrls`(void`(`*`)`(One`<Ctrl`>`&`)`): [_^ArrayCtrl`:`:Column^ C 2839olumn][@(0.0.255) `&]_[* Ctrls]([@(0.0.255) void]_(`*[*@3 factory])(One<Ctrl>`&))&] 2840[s2; The methods sets up a factory which the ArrayCtrl uses as necessary 2841to create new Ctrl`'s for editing a given column. The argument 2842of this function is a function pointer, which, upon execution, 2843should allocate (normally using the One`::Create method) the desired 2844editor object and set it to its argument. If the position of 2845Ctrl is equivalent to `'SetRect(0, 0, 0, 0)`', which is the default 2846value, Ctrl is resized to fit the ArrayCtrl cell accurately, 2847spanning the whole width and using STDSIZE for height, otherwise 2848the position represents the position within the cell.&] 2849[s7; [*C@3 factory]-|a global function used for editor control creation&] 2850[s7; [*/ Return value]-|[* `*this]&] 2851[s3; &] 2852[s4; &] 2853[s5;:ArrayCtrl`:`:Column`:`:Ctrls`(`): [@(0.0.255) template]_<[@(0.0.255) class]_[*@4 T]>_[_^ArrayCtrl`:`:Column^ C 2854olumn][@(0.0.255) `&]_[* Ctrls]()&] 2855[s2; This member template sets up a default factory for creating 2856editor controls of a given type. Every time the ArrayCtrl needs 2857to create a new editor control, an object of the type [* T] is 2858created automatically (using the [* new] operator). If the position 2859of Ctrl is equivalent to `'SetRect(0, 0, 0, 0)`', which is the 2860default value, Ctrl is resized to fit the ArrayCtrl cell accurately, 2861spanning the whole width and using STDSIZE for height, otherwise 2862the position represents the position within the cell.&] 2863[s7; [*C@4 T]-|the desired object editor type &] 2864[s7; [*/ Return value]-|[* `*this]&] 2865[s3; &] 2866[s4;%- &] 2867[s5;:Upp`:`:ArrayCtrl`:`:Column`:`:WithLined`(Upp`:`:Event`<int`,Upp`:`:One`<Upp`:`:Ctrl`>`&`>`):%- [_^Upp`:`:ArrayCtrl`:`:Column^ A 2868rrayCtrl`::Column][@(0.0.255) `&]_[* WithLined]([_^Upp`:`:Event^ Event]<[@(0.0.255) int], 2869[_^Upp`:`:One^ One]<[_^Upp`:`:Ctrl^ Ctrl]>`&>_[*@3 factory])&] 2870[s2; This method sets up a factory which the ArrayCtrl uses to create 2871new Ctrl`'s for editing a given column. The argument, a global 2872function, is supposed to create a new editor control in the second 2873argument (usually using the One`::Create method). The first argument 2874of Event is the line index. If the position of Ctrl is equivalent 2875to `'SetRect(0, 0, 0, 0)`', which is the default value, Ctrl 2876is resized to fit the ArrayCtrl cell accurately, spanning the 2877whole width and using STDSIZE for height, otherwise the position 2878represents the position within the cell.&] 2879[s3; &] 2880[s4;%- &] 2881[s5;:Upp`:`:ArrayCtrl`:`:Column`:`:With`(Upp`:`:Event`<Upp`:`:One`<Upp`:`:Ctrl`>`&`>`):%- [_^Upp`:`:ArrayCtrl`:`:Column^ A 2882rrayCtrl`::Column][@(0.0.255) `&]_[* With]([_^Upp`:`:Event^ Event]<[_^Upp`:`:One^ One]<[_^Upp`:`:Ctrl^ C 2883trl]>`&>_[*@3 factory])&] 2884[s2; This method sets up a factory which the ArrayCtrl uses to create 2885new Ctrl`'s for editing a given column. The argument, a global 2886function, is supposed to create a new editor control in the argument 2887(usually using the One`::Create method). If the position of Ctrl 2888is equivalent to `'SetRect(0, 0, 0, 0)`', which is the default 2889value, Ctrl is resized to fit the ArrayCtrl cell accurately, 2890spanning the whole width and using STDSIZE for height, otherwise 2891the position represents the position within the cell.&] 2892[s3; &] 2893[s4; &] 2894[s5;:ArrayCtrl`:`:Column`:`:InsertValue`(const Value`&`): [_^ArrayCtrl`:`:Column^ Colum 2895n][@(0.0.255) `&]_[* InsertValue]([@(0.0.255) const]_[_^Value^ Value][@(0.0.255) `&]_[*@3 v]) 2896&] 2897[s2; Instructs the ArrayCtrl object to initialize this column in 2898newly created rows to the given value [/ v]. (This applies only 2899to GUI`-based row insertion using methods like [* DoInsert] etc., 2900the low`-level, programmer`-controlled row insertion methods 2901like [* Add] or [* Insert] always initialize the source data matrix 2902with [* Null]`'s).&] 2903[s7; [*C@3 v]-|the value to use as the default for newly inserted rows&] 2904[s7; [*/ Return value]-|[* `*this]&] 2905[s3; &] 2906[s4; &] 2907[s5;:ArrayCtrl`:`:Column`:`:InsertValue`(ValueGen`&`): [_^ArrayCtrl`:`:Column^ Column][@(0.0.255) `& 2908]_[* InsertValue]([_^ValueGen^ ValueGen][@(0.0.255) `&]_[*@3 g])&] 2909[s2; Programs the ArrayCtrl object to use the given [* ValueGen] factory 2910for default value generation for newly created rows. This can 2911be used e.g. to generate unique UUID`'s or primary keys using 2912an Oracle SEQUENCE object for a primary key column.&] 2913[s7; [*C@3 g]-|a reference to the ValueGen object used for default value 2914generation&] 2915[s7; [*/ Return value]-|[* `*this]&] 2916[s3; &] 2917[s4; &] 2918[s5;:ArrayCtrl`:`:Column`:`:NoClickEdit`(`): [_^ArrayCtrl`:`:Column^ Column][@(0.0.255) `& 2919]_[* NoClickEdit]()&] 2920[s2; Disables entering the editing mode when clicking the respective 2921column.&] 2922[s7; [*/ Return value]-|[* `*this]&] 2923[s3; &] 2924[s4; &] 2925[s5;:ArrayCtrl`:`:Column`:`:Cache`(`): [_^ArrayCtrl`:`:Column^ Column][@(0.0.255) `&]_[* Ca 2926che]()&] 2927[s2; Enables using the cache to store the converted values of this 2928column. By default, converted value caching is turned off to 2929make cell value conversion entirely dynamic; however, very often 2930it is advisable to enable using the cache, especially when the 2931conversion is relatively slow (for instance, when the conversion 2932queries a database connection to convert the value).&] 2933[s7; [*/ Return value]-|[* `*this]&] 2934[s3; &] 2935[s4; &] 2936[s5;:ArrayCtrl`:`:Column`:`:Accel`(int`(`*`)`(int`)`): [_^ArrayCtrl`:`:Column^ Column][@(0.0.255) `& 2937]_[* Accel]([@(0.0.255) int]_(`*[*@3 filter])([@(0.0.255) int]))&] 2938[s2; Sets up the accelerator for the given column. A given filtering 2939function is used to convert keystrokes before acceleration.&] 2940[s7; [*C@3 filter]-|a [* CharConvert]`-style function to use for keystroke 2941conversion&] 2942[s7; [*/ Return value]-|[* `*this]&] 2943[s3; &] 2944[s4; &] 2945[s5;:ArrayCtrl`:`:Column`:`:Accel`(`): [_^ArrayCtrl`:`:Column^ Column][@(0.0.255) `&]_[* Ac 2946cel]()&] 2947[s2; Sets up the accelerator for the given column. No keystroke conversion 2948is performed.&] 2949[s7; [*/ Return value]-|[* `*this]&] 2950[s3; &] 2951[s4; &] 2952[s5;:ArrayCtrl`:`:Column`:`:Margin`(int`): [_^ArrayCtrl`:`:Column^ Column][@(0.0.255) `&]_ 2953[* Margin]([@(0.0.255) int]_[*@3 m])&] 2954[s2; Sets up the margin width for the given column. This is equivalent 2955to calling the [*^topic`:`/`/CtrlLib`/src`/HeaderCtrl`$en`-us`#`:`:HeaderCtrl`:`:Column`:`:SetMargin`(int`)^ S 2956etMargin] method of the underlying [* HeaderTab].&] 2957[s7; [*C@3 m]-|&] 2958[s7; [*/ Return value]-|[* `*this]&] 2959[s3; &] 2960[s4; &] 2961[s5;:ArrayCtrl`:`:Column`:`:Sorting`(const ValueOrder`&`): [_^ArrayCtrl`:`:Column^ Colu 2962mn][@(0.0.255) `&]_[* Sorting]([@(0.0.255) const]_[_^ValueOrder^ ValueOrder][@(0.0.255) `&]_ 2963[*@3 o])&] 2964[s5;:ArrayCtrl`:`:Column`:`:Sorting`(`): [_^ArrayCtrl`:`:Column^ Column][@(0.0.255) `&]_[* S 2965orting]()&] 2966[s2; Activates sorting of ArrayCtrl column by clicking on its header 2967tab. Parameterless version uses default Value ordering using 2968StdValueCompare.&] 2969[s3; &] 2970[s4;%- &] 2971[s5;:Upp`:`:ArrayCtrl`:`:Column`:`:SortingLined`(Upp`:`:Gate`<int`,int`>`):%- [_^Upp`:`:ArrayCtrl`:`:Column^ A 2972rrayCtrl`::Column][@(0.0.255) `&]_[* SortingLined]([_^Upp`:`:Gate^ Gate]<[@(0.0.255) int], 2973 [@(0.0.255) int]>_[*@3 aorder])&] 2974[s2; Activates sorting of ArrayCtrl column by clicking on its header 2975tab. This variant uses a Gate2 predicate that is supposed to 2976compare two lines (it has indicies as parameters). Note that 2977this variant ignores ascending/descending order, it has to be 2978implemented in predicate, using ArrayCtrl`::IsSortDescending to 2979determine the order.&] 2980[s3; &] 2981[s4;%- &] 2982[s5;:Upp`:`:ArrayCtrl`:`:Column`:`:SortingBy`(Upp`:`:Function`<int`(const Upp`:`:Value`&a`,const Upp`:`:Value`&b`)`>`):%- [_^Upp`:`:ArrayCtrl`:`:Column^ A 2983rrayCtrl`::Column][@(0.0.255) `&]_[* SortingBy]([_^Upp`:`:Function^ Function]<[@(0.0.255) i 2984nt]_([@(0.0.255) const]_Value[@(0.0.255) `&]_a, [@(0.0.255) const]_Value[@(0.0.255) `&]_b 2985)>_[*@3 c])&] 2986[s2; Activates sorting of ArrayCtrl column by clicking on its header 2987tab, using [%-*@3 c] to compare values of column. [%-*@3 c] should 2988return `-1, 0, 1 for <, `=, >.&] 2989[s3; &] 2990[s4;%- &] 2991[s5;:Upp`:`:ArrayCtrl`:`:Column`:`:SortDefault`(bool`):%- [_^Upp`:`:ArrayCtrl`:`:Column^ A 2992rrayCtrl`::Column][@(0.0.255) `&]_[* SortDefault]([@(0.0.255) bool]_[*@3 desc] 2993`= [@(0.0.255) false])&] 2994[s2;%- [%% Sets this column to be initial sorting column (calls SetSortColumn 2995of ArrayCtrl). If none of Sorting/SortingBy/SortingLines methods 2996was called on this column yet, calls default Sorting for the 2997column too. If ][*@3 desc] is true, sorting is in descending order.&] 2998[s3; &] 2999[s4; &] 3000[s5;:ArrayCtrl`:`:Column`:`:HeaderTab`(`): [_^HeaderCtrl`:`:Column^ HeaderCtrl`::Column][@(0.0.255) `& 3001]_[* HeaderTab]()&] 3002[s5;:ArrayCtrl`:`:Column`:`:HeaderTab`(`)const: [@(0.0.255) const]_[_^HeaderCtrl`:`:Column^ H 3003eaderCtrl`::Column][@(0.0.255) `&]_[* HeaderTab]()_[@(0.0.255) const]&] 3004[s2; Returns the [* HeaderCtrl`::Column] object describing the given 3005column. This object can be used to set up additional column properties 3006(like column width constraints or the [*^topic`:`/`/CtrlLib`/src`/HeaderCtrl`$en`-us`#`:`:HeaderCtrl`:`:Column`:`:Callback WhenAction^ W 3007henAction] callback).&] 3008[s3; &] 3009[s4; &] 3010[s5;:ArrayCtrl`:`:Column`:`:Tip`(const char`*`): [_^ArrayCtrl`:`:Column^ Column][@(0.0.255) `& 3011]_[* Tip]([@(0.0.255) const]_[@(0.0.255) char]_`*[*@3 tip])&] 3012[s2; Assigns a [*@3 tip] to header tab column.&] 3013[s3; &] 3014[s0; &] 3015[ {{10000t/25b/25@3 [s0; [*@(229)4 ArrayCtrl`::Order]]}}&] 3016[s3; &] 3017[s1;:ArrayCtrl`:`:Order`:`:struct: [@(0.0.255)3 struct][3 _][*3 Order]&] 3018[s9; The [* Order] object is used for array row sorting. The overloaded 3019[* operator ()] acts as the sorting predicate, which is consulted 3020within the sorting method to determine which of a given pair 3021of row is `'less`' according to the desired sorting.&] 3022[s3; &] 3023[s0; &] 3024[ {{10000F(128)G(128)@1 [s0; [* Public Member List]]}}&] 3025[s3; &] 3026[s5;:ArrayCtrl`:`:Order`:`:operator`(`)`(const Vector`<Value`>`&`,const Vector`<Value`>`&`)const: [@(0.0.255) v 3027irtual] [@(0.0.255) bool]_[* operator()]([@(0.0.255) const]_[_^Vector^ Vector]<[_^Value^ Va 3028lue]>`&_[*@3 row1], [@(0.0.255) const]_[_^Vector^ Vector]<[_^Value^ Value]>`&_[*@3 row2])_[@(0.0.255) c 3029onst]_`=_[@3 0]&] 3030[s2; The sorting predicate. This method should return [* true] when 3031its first argument ([/ row1]) is less than the second argument 3032([/ row2]) according to the desired ordering.&] 3033[s7; [*C@3 row1]-|an array of source data index values for the first 3034of the rows to compare&] 3035[s7; [*C@3 row2]-|an array of source data index values for the other 3036row to compare&] 3037[s7; [*/ Return value]-|[* true] `= row1 < row2, [* false] `= row1 >`= row2&] 3038[s3; &] 3039[s0; ]]