Global

Overridable for alternative or faster logic.

Create a custom definition of CellEvent for each grid instance, setting the grid, behavior, and dataModel properties on the prototype. As this happens once per grid instantiation, it avoids having to perform this set up work on every CellEvent instantiation.

The standard registry consists of a single theme, default, built from values in defaults.js.

Represents the ordered set of visible columns. Array size is always the exact number of visible columns, the last of which may only be partially visible.

This sequence of elements' columnIndex values assumes one of three patterns. Which pattern is base on the following two questions:

• Are there "fixed" columns on the left?
• Is the grid horizontally scrolled?

The set of columnIndex values consists of:

1. The first element will be -1 if the row handle column is being rendered.
2. A zero-based list of consecutive of integers representing the fixed columns (if any).
3. An n-based list of consecutive of integers representing the scrollable columns (where n = number of fixed columns + the number of columns scrolled off to the left).

Represents the ordered set of visible rows. Array size is always the exact number of visible rows.

The sequence of elements' rowIndex values is local to each subgrid.

• For each non-scrollable subgrid: The sequence is a zero-based list of consecutive integers.
• For the scrollable subgrid:
  1. A zero-based list of consecutive of integers representing the fixed rows (if any).
  2. An n-based list of consecutive of integers representing the scrollable rows (where n = number of fixed rows + the number of rows scrolled off the top).

Note that non-scrollable subgrids can come both before and after the scrollable subgrid.

Adds . The properties collection is optionally cleared first. Falsy elements are ignored.

This function creates several data structures:

• Renderer#visibleColumns
• Renderer#visibleRows

Original comment: "this function computes the grid coordinates used for extremely fast iteration over painting the grid cells. this function is very fast, for thousand rows X 100 columns on a modest machine taking usually 0ms and no more that 3 ms."

The $rowProxy$ lazy getter collection is returned by the getRow fallback.

$rowProxy$ collection is a dataRow-like object (a hash of column values keyed by column name) for the particular row whose index is in the $y$ property.

The row index can be conveniently set with a call to fallbacks.getRow(), which sets the row index and returns the accessor itself.

$y$ is a "hidden" property, non-enumerable it won't show up in Object.keys(...).

This fallback implementation is "lazy": The enumerable members are all getters that invoke getValue and setters that invoke setValue.

This function should be called each time a new schema is set.

Called from renderer/index.js

User is warned and new property is returned or new method is called and the result is returned.

This function is not called by Hypergrid. Rather, it is handed to the data model (by injectCode as dispatchEvent) to issue callbacks to the grid.

This handler:

1. Checks the event string to make sure it conforms to the expected syntax:
   • Starts with fin-hypergrid-data- or fin-hypergrid-schema-
   • Includes only lowercase letters and hyphens
2. Calls a handler in the dataModelEventHandlers namespace of the same name as the event string.
3. Re-emits the event as a DOM event to the <canvas> element (unless the handler has already done so).

The data model's dispatchEvent method is bound to the grid by injectCode. A bound version of this function, bound to the grid instance, is either:

• Added to the data model via its addListener method, if it has one; or
• Force-injected into the data model, overriding any native implementation. (A native implementation may exist simply to "catch" calls that might be made before the data model is attached to Hypergrid.)

This function expects to be passed an error. There is no point in calling this function if there is no error. Nevertheless, if called with a falsy error, returns without doing anything.

Calculate the minimum left column index so the target column shows up in viewport (we need to be aware of viewport's width, number of fixed columns and each column's width)

When grid.properties.fetchSubregions is true, this function needs to handle:

1. unordered columns
2. column gaps (hidden columns)
3. the single row gap that results when there are fixed rows and remaining rows are scrolled down

Similar to getTextWidth except:

1. Aborts accumulating when sum exceeds given width.
2. Returns an object containing both the truncated string and the sum (rather than a number primitive containing the sum alone).

Matrix of unformatted values of visible cells.

Navigate away from the filter cell when:

1. Coming from a cell editor (event.detail.editor defined).
2. The cell editor was for a filter cell.
3. The key (`event.detail.char) maps (through navKeyMap) to one of:
   • 'UP' or 'DOWN' - Selects first visible data cell under filter cell.
   • 'LEFT' - Opens filter cell editor in previous filterable column; if nonesuch, selects first visible data cell under filter cell.
   • 'RIGHT' - Opens filter cell editor in next filterable column; if nonesuch, selects first visible data cell under filter cell.

Certain renderers that pre-bundle column rects based on columns' background colors need to re-bundle when columns' background colors change. This method sets the rebundle property to true for those renderers that have that property.

Resets the cell properties cache in the matching CellEvent object from the renderer's pool. This will insure that a new cell properties object will be known to the renderer. (Normally, the cache is not reset until the pool is updated by the next call to Renderer#computeCellBounds).

Handle column width is sum of:

• Width of text the maximum row number, if visible, based on handle column's current font
• Width of checkbox, if visible
• Some padding

Calculators are functions. Column calculators are saved in grid.properties.calculators using the function name as key. Anonymous functions use the stringified function itself as the key. This may seem pointless, but this achieves the objective here which is to share function instances.

Sets multiple columns' properties from elements of given array or collection. Keys may be column indexes or column names. The properties collection is cleared first. Falsy elements are ignored.

Besides type, your event object can contain other event details.

After calling the internal handler found in src/behaviors/Local/events.js matching the event name, Hypergrid then creates a CustomEvent with the same name, sets its detail property to this object, and dispatches to the <canvas> element — to be picked up by any listeners previously attached with Hypergrid#addEventListener.

A data row representation. The properties of this object are the data fields. The property keys are the column names. All row objects should be congruent, meaning that each data row should have the same property keys.

One of:

• simple API - a plain object with an install method
• object API - an object constructor
• array:
  • first element is an optional name for the API or the newly instantiated object
  • next element (or first element when not a string) is the simple or object API
  • remaining arguments are optional arguments for the object constructor
• falsy value such as undefined - ignored

The API may have a name or $$CLASS_NAME property.

Column schema may be expressed as a string primitive on input to setData.

One of:

• function type - Assumed to already be a data model constructor.
• string type - The name of a data model "class" (constructor) registered in the src/dataModels namespace. Used to look up the constructor in the namespace.

One of:

• object type (except when an array) - Assumed to be a reference to an already-instantiated data model. Used as is.
• 'data' special value - Set to the data subgrid (i.e., the behavior's already-instantiated data model).
• subgridConstructorRef (see) - The constructor ref is resolved and called with the new keyword + a reference to the grid as the sole parameter.
• Array object — Accommodates data model constructor arguments. The constructor ref is resolved and called with the new keyword + a reference to the grid as the first parameter + the remaining elements as additional parameters. (If you don't have remaining elements, don't give an array here; just provide a simple subgridConstructorRef instead.) The array should have two or more elements:
  • The first element is a subgridConstructorRef.
  • Remaining elements are used as additional parameters to the constructor.