Skip to content

Cell Values

Jump to bottom
Jonathan Eiten edited this page Apr 12, 2017 · 2 revisions

The value of an individual grid cell (a particular field in a particular data row) is typically a JavaScript primitive value.

A cell value can, however, be any kind of object, subject to the cell renderer's ability to interpret that object.

For example, a sparkline cell renderer might expect to find an array of numbers.

A cell value can even be an instantiated object, including a function — although this will require some riviving if the source of your data is JSON.

When a cell value is a function, it is called a computed cell or computed value; the function itself is called the cell's calculator.

Computing cell value

How a cell value is computed depends entirely on the cell renderer.

For greater performance, the cell renderer can make assumptions about the cell value, assuming for example that it is always a calculator, or assuming that it is never a calculator.

A more flexible (but less performant) cell renderer will however follow this general algorithm:

  1. If the cell has its own calculator, call it.
  2. Otherwise, if the column has a calculator, call it.
  3. Otherwise, use the cell value as is.

This common algorithm is provided in a function on the config object passed to the cell renderer:

functionmyCellRenderer(gc,config){varvalue=config.exec(config.value);//code to render `value` goes here}

exec calls the calculator in a standard way (see Calculator Calling Conventions, below).

A standard is necessary if your data model performs any data analytics, by which we mean observing the values in cells. A data model that simply returns the data does no analytics. But a data model that provides any additional services, such as filtering or sorting on the client, will need to compare values between rows, and therefore will need to know how to call calculators, when present, to get those values.

The data model has very limited information about the cell, including only the cell's data coordinates, column name, type, and calculator. Unlike the cell renderer, it may not make any assumptions, and therefore always needs to check for a calculator, and if found needs to call it on its own, using the same calling convention as the cell renderers.

Calculator Calling Conventions

The standard calculator calling convention, as embodied by Hypergrid.defaults.exec, consists of two parameters:

  1. A hash containing all the values of all the columns in the current grid row (keyed by column name)
  2. A string containing the name of the present column

You are free to choose a different standard for your calling convention; but if your data model performs any analytics, it must use the same standard. You can easily override exec (owned by the Hypergrid.defaults object), but note that the config object, including config.exec, is only useful for rendering. It is constructed at render time to reflect the specific cell being rendered and is not applicable to other cells. It is made available to the cell renderer only but is never available to the data model.

Clone this wiki locally

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
Cell Values · fin-hypergrid/core Wiki · GitHub
Skip to content
Cell Values
Jump to bottom

Jonathan Eiten edited this page Apr 12, 2017
·
2 revisions
The value of an individual grid cell (a particular field in a particular data row) is typically a JavaScript primitive value.
A cell value can, however, be any kind of object, subject to the cell renderer's ability to interpret that object.
For example, a sparkline cell renderer might expect to find an array of numbers.
A cell value can even be an instantiated object, including a function — although this will require some riviving if the source of your data is JSON.
When a cell value is a function, it is called a computed cell or computed value; the function itself is called the cell's calculator.
Computing cell value
How a cell value is computed depends entirely on the cell renderer.
For greater performance, the cell renderer can make assumptions about the cell value, assuming for example that it is always a calculator, or assuming that it is never a calculator.
A more flexible (but less performant) cell renderer will however follow this general algorithm:
  1. If the cell has its own calculator, call it.
  2. Otherwise, if the column has a calculator, call it.
  3. Otherwise, use the cell value as is.
This common algorithm is provided in a function on the config object passed to the cell renderer:
functionmyCellRenderer(gc,config){varvalue=config.exec(config.value);//code to render `value` goes here}
exec calls the calculator in a standard way (see Calculator Calling Conventions, below).
A standard is necessary if your data model performs any data analytics, by which we mean observing the values in cells. A data model that simply returns the data does no analytics. But a data model that provides any additional services, such as filtering or sorting on the client, will need to compare values between rows, and therefore will need to know how to call calculators, when present, to get those values.
The data model has very limited information about the cell, including only the cell's data coordinates, column name, type, and calculator. Unlike the cell renderer, it may not make any assumptions, and therefore always needs to check for a calculator, and if found needs to call it on its own, using the same calling convention as the cell renderers.
Calculator Calling Conventions
The standard calculator calling convention, as embodied by Hypergrid.defaults.exec, consists of two parameters:
  1. A hash containing all the values of all the columns in the current grid row (keyed by column name)
  2. A string containing the name of the present column
You are free to choose a different standard for your calling convention; but if your data model performs any analytics, it must use the same standard. You can easily override exec (owned by the Hypergrid.defaults object), but note that the config object, including config.exec, is only useful for rendering. It is constructed at render time to reflect the specific cell being rendered and is not applicable to other cells. It is made available to the cell renderer only but is never available to the data model.
Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Cell Values · fin-hypergrid/core Wiki · GitHub
Skip to content
Cell Values
Jump to bottom

Jonathan Eiten edited this page Apr 12, 2017
·
2 revisions
The value of an individual grid cell (a particular field in a particular data row) is typically a JavaScript primitive value.
A cell value can, however, be any kind of object, subject to the cell renderer's ability to interpret that object.
For example, a sparkline cell renderer might expect to find an array of numbers.
A cell value can even be an instantiated object, including a function — although this will require some riviving if the source of your data is JSON.
When a cell value is a function, it is called a computed cell or computed value; the function itself is called the cell's calculator.
Computing cell value
How a cell value is computed depends entirely on the cell renderer.
For greater performance, the cell renderer can make assumptions about the cell value, assuming for example that it is always a calculator, or assuming that it is never a calculator.
A more flexible (but less performant) cell renderer will however follow this general algorithm:
  1. If the cell has its own calculator, call it.
  2. Otherwise, if the column has a calculator, call it.
  3. Otherwise, use the cell value as is.
This common algorithm is provided in a function on the config object passed to the cell renderer:
functionmyCellRenderer(gc,config){varvalue=config.exec(config.value);//code to render `value` goes here}
exec calls the calculator in a standard way (see Calculator Calling Conventions, below).
A standard is necessary if your data model performs any data analytics, by which we mean observing the values in cells. A data model that simply returns the data does no analytics. But a data model that provides any additional services, such as filtering or sorting on the client, will need to compare values between rows, and therefore will need to know how to call calculators, when present, to get those values.
The data model has very limited information about the cell, including only the cell's data coordinates, column name, type, and calculator. Unlike the cell renderer, it may not make any assumptions, and therefore always needs to check for a calculator, and if found needs to call it on its own, using the same calling convention as the cell renderers.
Calculator Calling Conventions
The standard calculator calling convention, as embodied by Hypergrid.defaults.exec, consists of two parameters:
  1. A hash containing all the values of all the columns in the current grid row (keyed by column name)
  2. A string containing the name of the present column
You are free to choose a different standard for your calling convention; but if your data model performs any analytics, it must use the same standard. You can easily override exec (owned by the Hypergrid.defaults object), but note that the config object, including config.exec, is only useful for rendering. It is constructed at render time to reflect the specific cell being rendered and is not applicable to other cells. It is made available to the cell renderer only but is never available to the data model.
Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Cell Values · fin-hypergrid/core Wiki · GitHub
Skip to content
Cell Values
Jump to bottom

Jonathan Eiten edited this page Apr 12, 2017
·
2 revisions
The value of an individual grid cell (a particular field in a particular data row) is typically a JavaScript primitive value.
A cell value can, however, be any kind of object, subject to the cell renderer's ability to interpret that object.
For example, a sparkline cell renderer might expect to find an array of numbers.
A cell value can even be an instantiated object, including a function — although this will require some riviving if the source of your data is JSON.
When a cell value is a function, it is called a computed cell or computed value; the function itself is called the cell's calculator.
Computing cell value
How a cell value is computed depends entirely on the cell renderer.
For greater performance, the cell renderer can make assumptions about the cell value, assuming for example that it is always a calculator, or assuming that it is never a calculator.
A more flexible (but less performant) cell renderer will however follow this general algorithm:
  1. If the cell has its own calculator, call it.
  2. Otherwise, if the column has a calculator, call it.
  3. Otherwise, use the cell value as is.
This common algorithm is provided in a function on the config object passed to the cell renderer:
functionmyCellRenderer(gc,config){varvalue=config.exec(config.value);//code to render `value` goes here}
exec calls the calculator in a standard way (see Calculator Calling Conventions, below).
A standard is necessary if your data model performs any data analytics, by which we mean observing the values in cells. A data model that simply returns the data does no analytics. But a data model that provides any additional services, such as filtering or sorting on the client, will need to compare values between rows, and therefore will need to know how to call calculators, when present, to get those values.
The data model has very limited information about the cell, including only the cell's data coordinates, column name, type, and calculator. Unlike the cell renderer, it may not make any assumptions, and therefore always needs to check for a calculator, and if found needs to call it on its own, using the same calling convention as the cell renderers.
Calculator Calling Conventions
The standard calculator calling convention, as embodied by Hypergrid.defaults.exec, consists of two parameters:
  1. A hash containing all the values of all the columns in the current grid row (keyed by column name)
  2. A string containing the name of the present column
You are free to choose a different standard for your calling convention; but if your data model performs any analytics, it must use the same standard. You can easily override exec (owned by the Hypergrid.defaults object), but note that the config object, including config.exec, is only useful for rendering. It is constructed at render time to reflect the specific cell being rendered and is not applicable to other cells. It is made available to the cell renderer only but is never available to the data model.
Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
Cell Values · fin-hypergrid/core Wiki · GitHub
Skip to content
Cell Values
Jump to bottom

Jonathan Eiten edited this page Apr 12, 2017
·
2 revisions
The value of an individual grid cell (a particular field in a particular data row) is typically a JavaScript primitive value.
A cell value can, however, be any kind of object, subject to the cell renderer's ability to interpret that object.
For example, a sparkline cell renderer might expect to find an array of numbers.
A cell value can even be an instantiated object, including a function — although this will require some riviving if the source of your data is JSON.
When a cell value is a function, it is called a computed cell or computed value; the function itself is called the cell's calculator.
Computing cell value
How a cell value is computed depends entirely on the cell renderer.
For greater performance, the cell renderer can make assumptions about the cell value, assuming for example that it is always a calculator, or assuming that it is never a calculator.
A more flexible (but less performant) cell renderer will however follow this general algorithm:
  1. If the cell has its own calculator, call it.
  2. Otherwise, if the column has a calculator, call it.
  3. Otherwise, use the cell value as is.
This common algorithm is provided in a function on the config object passed to the cell renderer:
functionmyCellRenderer(gc,config){varvalue=config.exec(config.value);//code to render `value` goes here}
exec calls the calculator in a standard way (see Calculator Calling Conventions, below).
A standard is necessary if your data model performs any data analytics, by which we mean observing the values in cells. A data model that simply returns the data does no analytics. But a data model that provides any additional services, such as filtering or sorting on the client, will need to compare values between rows, and therefore will need to know how to call calculators, when present, to get those values.
The data model has very limited information about the cell, including only the cell's data coordinates, column name, type, and calculator. Unlike the cell renderer, it may not make any assumptions, and therefore always needs to check for a calculator, and if found needs to call it on its own, using the same calling convention as the cell renderers.
Calculator Calling Conventions
The standard calculator calling convention, as embodied by Hypergrid.defaults.exec, consists of two parameters:
  1. A hash containing all the values of all the columns in the current grid row (keyed by column name)
  2. A string containing the name of the present column
You are free to choose a different standard for your calling convention; but if your data model performs any analytics, it must use the same standard. You can easily override exec (owned by the Hypergrid.defaults object), but note that the config object, including config.exec, is only useful for rendering. It is constructed at render time to reflect the specific cell being rendered and is not applicable to other cells. It is made available to the cell renderer only but is never available to the data model.
Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Cell Values · fin-hypergrid/core Wiki · GitHub
Skip to content
Cell Values
Jump to bottom

Jonathan Eiten edited this page Apr 12, 2017
·
2 revisions
The value of an individual grid cell (a particular field in a particular data row) is typically a JavaScript primitive value.
A cell value can, however, be any kind of object, subject to the cell renderer's ability to interpret that object.
For example, a sparkline cell renderer might expect to find an array of numbers.
A cell value can even be an instantiated object, including a function — although this will require some riviving if the source of your data is JSON.
When a cell value is a function, it is called a computed cell or computed value; the function itself is called the cell's calculator.
Computing cell value
How a cell value is computed depends entirely on the cell renderer.
For greater performance, the cell renderer can make assumptions about the cell value, assuming for example that it is always a calculator, or assuming that it is never a calculator.
A more flexible (but less performant) cell renderer will however follow this general algorithm:
  1. If the cell has its own calculator, call it.
  2. Otherwise, if the column has a calculator, call it.
  3. Otherwise, use the cell value as is.
This common algorithm is provided in a function on the config object passed to the cell renderer:
functionmyCellRenderer(gc,config){varvalue=config.exec(config.value);//code to render `value` goes here}
exec calls the calculator in a standard way (see Calculator Calling Conventions, below).
A standard is necessary if your data model performs any data analytics, by which we mean observing the values in cells. A data model that simply returns the data does no analytics. But a data model that provides any additional services, such as filtering or sorting on the client, will need to compare values between rows, and therefore will need to know how to call calculators, when present, to get those values.
The data model has very limited information about the cell, including only the cell's data coordinates, column name, type, and calculator. Unlike the cell renderer, it may not make any assumptions, and therefore always needs to check for a calculator, and if found needs to call it on its own, using the same calling convention as the cell renderers.
Calculator Calling Conventions
The standard calculator calling convention, as embodied by Hypergrid.defaults.exec, consists of two parameters:
  1. A hash containing all the values of all the columns in the current grid row (keyed by column name)
  2. A string containing the name of the present column
You are free to choose a different standard for your calling convention; but if your data model performs any analytics, it must use the same standard. You can easily override exec (owned by the Hypergrid.defaults object), but note that the config object, including config.exec, is only useful for rendering. It is constructed at render time to reflect the specific cell being rendered and is not applicable to other cells. It is made available to the cell renderer only but is never available to the data model.
Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Cell Values · fin-hypergrid/core Wiki · GitHub
Skip to content
Cell Values
Jump to bottom

Jonathan Eiten edited this page Apr 12, 2017
·
2 revisions
The value of an individual grid cell (a particular field in a particular data row) is typically a JavaScript primitive value.
A cell value can, however, be any kind of object, subject to the cell renderer's ability to interpret that object.
For example, a sparkline cell renderer might expect to find an array of numbers.
A cell value can even be an instantiated object, including a function — although this will require some riviving if the source of your data is JSON.
When a cell value is a function, it is called a computed cell or computed value; the function itself is called the cell's calculator.
Computing cell value
How a cell value is computed depends entirely on the cell renderer.
For greater performance, the cell renderer can make assumptions about the cell value, assuming for example that it is always a calculator, or assuming that it is never a calculator.
A more flexible (but less performant) cell renderer will however follow this general algorithm:
  1. If the cell has its own calculator, call it.
  2. Otherwise, if the column has a calculator, call it.
  3. Otherwise, use the cell value as is.
This common algorithm is provided in a function on the config object passed to the cell renderer:
functionmyCellRenderer(gc,config){varvalue=config.exec(config.value);//code to render `value` goes here}
exec calls the calculator in a standard way (see Calculator Calling Conventions, below).
A standard is necessary if your data model performs any data analytics, by which we mean observing the values in cells. A data model that simply returns the data does no analytics. But a data model that provides any additional services, such as filtering or sorting on the client, will need to compare values between rows, and therefore will need to know how to call calculators, when present, to get those values.
The data model has very limited information about the cell, including only the cell's data coordinates, column name, type, and calculator. Unlike the cell renderer, it may not make any assumptions, and therefore always needs to check for a calculator, and if found needs to call it on its own, using the same calling convention as the cell renderers.
Calculator Calling Conventions
The standard calculator calling convention, as embodied by Hypergrid.defaults.exec, consists of two parameters:
  1. A hash containing all the values of all the columns in the current grid row (keyed by column name)
  2. A string containing the name of the present column
You are free to choose a different standard for your calling convention; but if your data model performs any analytics, it must use the same standard. You can easily override exec (owned by the Hypergrid.defaults object), but note that the config object, including config.exec, is only useful for rendering. It is constructed at render time to reflect the specific cell being rendered and is not applicable to other cells. It is made available to the cell renderer only but is never available to the data model.
Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
Cell Values · fin-hypergrid/core Wiki · GitHub
Skip to content
Cell Values
Jump to bottom

Jonathan Eiten edited this page Apr 12, 2017
·
2 revisions
The value of an individual grid cell (a particular field in a particular data row) is typically a JavaScript primitive value.
A cell value can, however, be any kind of object, subject to the cell renderer's ability to interpret that object.
For example, a sparkline cell renderer might expect to find an array of numbers.
A cell value can even be an instantiated object, including a function — although this will require some riviving if the source of your data is JSON.
When a cell value is a function, it is called a computed cell or computed value; the function itself is called the cell's calculator.
Computing cell value
How a cell value is computed depends entirely on the cell renderer.
For greater performance, the cell renderer can make assumptions about the cell value, assuming for example that it is always a calculator, or assuming that it is never a calculator.
A more flexible (but less performant) cell renderer will however follow this general algorithm:
  1. If the cell has its own calculator, call it.
  2. Otherwise, if the column has a calculator, call it.
  3. Otherwise, use the cell value as is.
This common algorithm is provided in a function on the config object passed to the cell renderer:
functionmyCellRenderer(gc,config){varvalue=config.exec(config.value);//code to render `value` goes here}
exec calls the calculator in a standard way (see Calculator Calling Conventions, below).
A standard is necessary if your data model performs any data analytics, by which we mean observing the values in cells. A data model that simply returns the data does no analytics. But a data model that provides any additional services, such as filtering or sorting on the client, will need to compare values between rows, and therefore will need to know how to call calculators, when present, to get those values.
The data model has very limited information about the cell, including only the cell's data coordinates, column name, type, and calculator. Unlike the cell renderer, it may not make any assumptions, and therefore always needs to check for a calculator, and if found needs to call it on its own, using the same calling convention as the cell renderers.
Calculator Calling Conventions
The standard calculator calling convention, as embodied by Hypergrid.defaults.exec, consists of two parameters:
  1. A hash containing all the values of all the columns in the current grid row (keyed by column name)
  2. A string containing the name of the present column
You are free to choose a different standard for your calling convention; but if your data model performs any analytics, it must use the same standard. You can easily override exec (owned by the Hypergrid.defaults object), but note that the config object, including config.exec, is only useful for rendering. It is constructed at render time to reflect the specific cell being rendered and is not applicable to other cells. It is made available to the cell renderer only but is never available to the data model.
Clone this wiki locally