//// DELAY CHECKER ////
(function () {
if (window.__scriptProfilerAuto) return;
const AUTO_STOP_MS = 2200; // tijd zonder nieuwe activiteit = meting klaar
const MAX_SESSION_MS = 8000; // harde limiet
const TOP_N = 15;
const state = {
activeSession: null,
sessions: [],
byScript: new Map(),
callStack: [],
originals: {},
observerMeta: new WeakMap(),
timerMeta: new Map(),
listenerMap: new WeakMap(),
pendingAutoStop: null,
pendingHardStop: null,
monitorInstalled: false
};
function now() {
return performance.now();
}
function extractScriptNameFromText(text) {
if (!text) return "ONBEKEND SCRIPT";
const m = text.match(/\/\/\/\/\s*([^\n\r]+?)\s*\/\/\/\//);
return m ? m[1].trim() : "ONBEKEND SCRIPT";
}
function currentScriptName() {
const cs = document.currentScript;
if (!cs) return state.callStack[state.callStack.length - 1] || "ONBEKEND SCRIPT";
return extractScriptNameFromText(cs.textContent || "");
}
function ensureBucket(scriptName) {
if (!state.byScript.has(scriptName)) {
state.byScript.set(scriptName, {
script: scriptName,
totalMs: 0,
events: 0,
observers: 0,
intervals: 0,
timeouts: 0,
rafs: 0,
querySelectorAll: 0,
querySelector: 0,
setAttribute: 0,
classListOps: 0,
styleOps: 0,
appendOps: 0,
removeOps: 0
});
}
return state.byScript.get(scriptName);
}
function markActivity() {
if (!state.activeSession) return;
if (state.pendingAutoStop) clearTimeout(state.pendingAutoStop);
state.pendingAutoStop = setTimeout(() => {
stopSession("idle");
}, AUTO_STOP_MS);
}
function addTime(scriptName, ms, kind) {
if (!state.activeSession) return;
const bucket = ensureBucket(scriptName);
bucket.totalMs += ms;
if (kind === "event") bucket.events += 1;
if (kind === "observer") bucket.observers += 1;
if (kind === "interval") bucket.intervals += 1;
if (kind === "timeout") bucket.timeouts += 1;
if (kind === "raf") bucket.rafs += 1;
markActivity();
}
function withScriptContext(scriptName, kind, fn, args, thisArg) {
const start = now();
state.callStack.push(scriptName);
try {
return fn.apply(thisArg, args || []);
} finally {
state.callStack.pop();
addTime(scriptName, now() - start, kind);
}
}
function wrapListener(listener, scriptName, eventType) {
if (!listener) return listener;
if (typeof listener === "function") {
const wrapped = function () {
return withScriptContext(scriptName, "event", listener, arguments, this);
};
state.listenerMap.set(listener, wrapped);
return wrapped;
}
if (typeof listener.handleEvent === "function") {
const wrappedObj = {
handleEvent: function () {
return withScriptContext(scriptName, "event", listener.handleEvent, arguments, listener);
}
};
state.listenerMap.set(listener, wrappedObj);
return wrappedObj;
}
return listener;
}
function patchAddEventListener() {
const proto = EventTarget.prototype;
state.originals.addEventListener = proto.addEventListener;
state.originals.removeEventListener = proto.removeEventListener;
proto.addEventListener = function (type, listener, options) {
const scriptName = currentScriptName();
const wrapped = wrapListener(listener, scriptName, type);
return state.originals.addEventListener.call(this, type, wrapped, options);
};
proto.removeEventListener = function (type, listener, options) {
const wrapped = state.listenerMap.get(listener) || listener;
return state.originals.removeEventListener.call(this, type, wrapped, options);
};
}
function patchTimers() {
state.originals.setTimeout = window.setTimeout;
state.originals.setInterval = window.setInterval;
state.originals.requestAnimationFrame = window.requestAnimationFrame;
window.setTimeout = function (fn, delay) {
const scriptName = currentScriptName();
const wrapped = typeof fn === "function"
? function () { return withScriptContext(scriptName, "timeout", fn, arguments, this); }
: fn;
return state.originals.setTimeout.call(window, wrapped, delay);
};
window.setInterval = function (fn, delay) {
const scriptName = currentScriptName();
const wrapped = typeof fn === "function"
? function () { return withScriptContext(scriptName, "interval", fn, arguments, this); }
: fn;
return state.originals.setInterval.call(window, wrapped, delay);
};
window.requestAnimationFrame = function (fn) {
const scriptName = currentScriptName();
const wrapped = function () {
return withScriptContext(scriptName, "raf", fn, arguments, this);
};
return state.originals.requestAnimationFrame.call(window, wrapped);
};
}
function patchMutationObserver() {
state.originals.MutationObserver = window.MutationObserver;
window.MutationObserver = function (callback) {
const scriptName = currentScriptName();
const wrapped = function () {
return withScriptContext(scriptName, "observer", callback, arguments, this);
};
return new state.originals.MutationObserver(wrapped);
};
}
function patchDomHeavyCalls() {
const qsaE = Element.prototype.querySelectorAll;
const qsE = Element.prototype.querySelector;
const qsaD = Document.prototype.querySelectorAll;
const qsD = Document.prototype.querySelector;
const setAttr = Element.prototype.setAttribute;
const appendChild = Node.prototype.appendChild;
const insertBefore = Node.prototype.insertBefore;
const removeChild = Node.prototype.removeChild;
state.originals.elementQuerySelectorAll = qsaE;
state.originals.elementQuerySelector = qsE;
state.originals.documentQuerySelectorAll = qsaD;
state.originals.documentQuerySelector = qsD;
state.originals.setAttribute = setAttr;
state.originals.appendChild = appendChild;
state.originals.insertBefore = insertBefore;
state.originals.removeChild = removeChild;
function mark(op) {
if (!state.activeSession) return;
const scriptName = state.callStack[state.callStack.length - 1];
if (!scriptName) return;
const bucket = ensureBucket(scriptName);
bucket[op] = (bucket[op] || 0) + 1;
markActivity();
}
Element.prototype.querySelectorAll = function (sel) {
mark("querySelectorAll");
return qsaE.call(this, sel);
};
Document.prototype.querySelectorAll = function (sel) {
mark("querySelectorAll");
return qsaD.call(this, sel);
};
Element.prototype.querySelector = function (sel) {
mark("querySelector");
return qsE.call(this, sel);
};
Document.prototype.querySelector = function (sel) {
mark("querySelector");
return qsD.call(this, sel);
};
Element.prototype.setAttribute = function (name, value) {
if (
name === "display" ||
name === "transform" ||
name === "d" ||
name === "points" ||
name === "x" ||
name === "width" ||
name === "height"
) {
mark("setAttribute");
}
return setAttr.call(this, name, value);
};
Node.prototype.appendChild = function (node) {
mark("appendOps");
return appendChild.call(this, node);
};
Node.prototype.insertBefore = function (node, ref) {
mark("appendOps");
return insertBefore.call(this, node, ref);
};
Node.prototype.removeChild = function (node) {
mark("removeOps");
return removeChild.call(this, node);
};
const classAdd = DOMTokenList.prototype.add;
const classRemove = DOMTokenList.prototype.remove;
const classToggle = DOMTokenList.prototype.toggle;
state.originals.classAdd = classAdd;
state.originals.classRemove = classRemove;
state.originals.classToggle = classToggle;
DOMTokenList.prototype.add = function () {
if (state.activeSession) {
const scriptName = state.callStack[state.callStack.length - 1];
if (scriptName) ensureBucket(scriptName).classListOps += 1;
markActivity();
}
return classAdd.apply(this, arguments);
};
DOMTokenList.prototype.remove = function () {
if (state.activeSession) {
const scriptName = state.callStack[state.callStack.length - 1];
if (scriptName) ensureBucket(scriptName).classListOps += 1;
markActivity();
}
return classRemove.apply(this, arguments);
};
DOMTokenList.prototype.toggle = function () {
if (state.activeSession) {
const scriptName = state.callStack[state.callStack.length - 1];
if (scriptName) ensureBucket(scriptName).classListOps += 1;
markActivity();
}
return classToggle.apply(this, arguments);
};
const styleSetProperty = CSSStyleDeclaration.prototype.setProperty;
state.originals.styleSetProperty = styleSetProperty;
CSSStyleDeclaration.prototype.setProperty = function () {
if (state.activeSession) {
const scriptName = state.callStack[state.callStack.length - 1];
if (scriptName) ensureBucket(scriptName).styleOps += 1;
markActivity();
}
return styleSetProperty.apply(this, arguments);
};
}
function startSession(triggerLabel) {
if (state.activeSession) stopSession("restart");
state.byScript.clear();
state.activeSession = {
label: triggerLabel,
startedAt: now()
};
if (state.pendingAutoStop) clearTimeout(state.pendingAutoStop);
if (state.pendingHardStop) clearTimeout(state.pendingHardStop);
state.pendingAutoStop = setTimeout(() => {
stopSession("idle");
}, AUTO_STOP_MS);
state.pendingHardStop = setTimeout(() => {
stopSession("max");
}, MAX_SESSION_MS);
console.log(`[AutoProfiler] gestart door: ${triggerLabel}`);
}
function stopSession(reason) {
if (!state.activeSession) return [];
if (state.pendingAutoStop) clearTimeout(state.pendingAutoStop);
if (state.pendingHardStop) clearTimeout(state.pendingHardStop);
const elapsed = now() - state.activeSession.startedAt;
const rows = Array.from(state.byScript.values())
.sort((a, b) => b.totalMs - a.totalMs)
.map(r => ({
script: r.script,
totalMs: Number(r.totalMs.toFixed(1)),
events: r.events,
observers: r.observers,
intervals: r.intervals,
timeouts: r.timeouts,
rafs: r.rafs,
querySelectorAll: r.querySelectorAll,
querySelector: r.querySelector,
setAttribute: r.setAttribute,
classListOps: r.classListOps,
styleOps: r.styleOps,
appendOps: r.appendOps,
removeOps: r.removeOps
}));
const topRows = rows.slice(0, TOP_N);
console.groupCollapsed(
`%c[AutoProfiler] ${state.activeSession.label} klaar`,
"color:#0a7;font-weight:bold;"
);
console.log(`reden: ${reason}`);
console.log(`duur: ${elapsed.toFixed(1)} ms`);
console.table(topRows);
console.log("volledige lijst:", rows);
console.groupEnd();
state.sessions.push({
label: state.activeSession.label,
reason,
elapsedMs: elapsed,
rows
});
state.activeSession = null;
return rows;
}
function isTargetField(el) {
if (!el || !el.name) return false;
return (
el.name === "form_fields[dorpeltype]" ||
el.name === "form_fields[vakken]"
);
}
function installAutoMonitor() {
if (state.monitorInstalled) return;
state.monitorInstalled = true;
document.addEventListener("change", function (e) {
const t = e.target;
if (!isTargetField(t)) return;
const value =
t.getAttribute("data-original-value") ||
t.value ||
"(leeg)";
startSession(`${t.name} = ${value}`);
}, true);
document.addEventListener("input", function (e) {
const t = e.target;
if (!isTargetField(t)) return;
const value =
t.getAttribute("data-original-value") ||
t.value ||
"(leeg)";
startSession(`${t.name} = ${value}`);
}, true);
}
patchAddEventListener();
patchTimers();
patchMutationObserver();
patchDomHeavyCalls();
installAutoMonitor();
window.__scriptProfilerAuto = {
sessions: state.sessions,
stopNow() {
return stopSession("manual");
},
last() {
return state.sessions[state.sessions.length - 1] || null;
},
all() {
return state.sessions;
}
};
console.log("[AutoProfiler] actief. Wijzig dorpeltype of vakken; output verschijnt automatisch in de console.");
})();
/// LOUPE #ALLE-VAKKEN ////
(() => {
const SVG_ID = "alle-vakken";
// Form conditions
const VAKKEN_SELECTOR = 'input[type="radio"][name="form_fields[vakken]"]';
const VVU_SELECTOR = 'select[id^="form-field-"][id*="VVU"]';
const ALLOWED_VVU_VALUES = new Set([
"linksschuivend",
"rechtsschuivend",
"linksrechtsschuivend",
]);
const MIN_VIEWBOX_WIDTH_EXCLUSIVE = 744;
// Loupe config
const LENS_DIAMETER_PX = 200;
const SCALE_FACTOR = 2;
const LENS_BACKGROUND = "#f4f4f4";
const NS = "http://www.w3.org/2000/svg";
const XLINK = "http://www.w3.org/1999/xlink";
const PREFIX = "z_";
const MAATVOERING_ID = "maatvoering-overlay";
// Control
let mouseOnSvg = false;
let loupeInitialized = false;
// Observers
let viewBoxObserver = null;
// Loupe internals
let syncObserver = null;
let zoomGroup = null;
let scaleGroup = null;
let border = null;
let clipEllipse = null;
let cloneRoot = null;
let lensBackground = null;
// Deferred rebuild
let pendingRebuild = false;
let lastPointerMoveAt = 0;
let rebuildTimer = null;
let syncing = false;
// Pointermove rAF throttle
let raf = 0;
let lastEvt = null;
function cssEscapeSafe(id) {
if (window.CSS && CSS.escape) return CSS.escape(id);
return id.replace(
/([ #;?%&,.+*~\':"!^$[\]()=>|\/@])/g,
"\\$1"
);
}
function getSvg() {
return document.getElementById(SVG_ID);
}
// ----------------- CONDITIONS -----------------
function vvuOk() {
const selects = Array.from(
document.querySelectorAll(VVU_SELECTOR)
);
if (!selects.length) return false;
return selects.some(sel =>
ALLOWED_VVU_VALUES.has(
String(sel.value || "").trim().toLowerCase()
)
);
}
function vakkenOk() {
return !!document.querySelector(
`${VAKKEN_SELECTOR}:checked`
);
}
function viewBoxWidthOk(svg) {
if (!svg) return false;
const vb = svg.viewBox?.baseVal;
if (vb && Number.isFinite(vb.width)) {
return vb.width > MIN_VIEWBOX_WIDTH_EXCLUSIVE;
}
const vbAttr = svg.getAttribute("viewBox") || "";
const parts = vbAttr.trim().split(/[\s,]+/).map(Number);
if (
parts.length >= 3 &&
Number.isFinite(parts[2])
) {
return parts[2] > MIN_VIEWBOX_WIDTH_EXCLUSIVE;
}
return false;
}
function baseConditionsOk() {
const svg = getSvg();
return !!svg &&
vvuOk() &&
vakkenOk() &&
viewBoxWidthOk(svg);
}
function activeConditionsOk() {
return baseConditionsOk() && mouseOnSvg;
}
// ----------------- SHOW/HIDE/CLEANUP -----------------
function hideLens() {
if (zoomGroup) zoomGroup.style.display = "none";
if (border) border.style.display = "none";
}
function showLens() {
if (zoomGroup) zoomGroup.style.display = "";
if (border) border.style.display = "";
}
function cleanupLoupe() {
const svg = getSvg();
if (!svg) return;
hideLens();
if (syncObserver) {
syncObserver.disconnect();
syncObserver = null;
}
if (rebuildTimer) {
clearInterval(rebuildTimer);
rebuildTimer = null;
}
const oldZoom = svg.querySelector('g#zoomLens');
const oldBorder = svg.querySelector('ellipse#zoomBorder');
const oldClip = svg.querySelector('defs #zoomClip');
if (oldZoom) oldZoom.remove();
if (oldBorder) oldBorder.remove();
if (oldClip) oldClip.remove();
zoomGroup = null;
scaleGroup = null;
border = null;
clipEllipse = null;
cloneRoot = null;
lensBackground = null;
pendingRebuild = false;
lastPointerMoveAt = 0;
syncing = false;
loupeInitialized = false;
}
// ----------------- VIEWBOX OBSERVER -----------------
function attachViewBoxObserverIfNeeded() {
const svg = getSvg();
if (!svg) return;
if (viewBoxObserver) {
viewBoxObserver.disconnect();
}
viewBoxObserver = new MutationObserver((muts) => {
for (const m of muts) {
if (
m.type === "attributes" &&
m.attributeName === "viewBox"
) {
if (!baseConditionsOk()) cleanupLoupe();
}
}
});
viewBoxObserver.observe(svg, {
attributes: true,
attributeFilter: ["viewBox"]
});
}
function detachViewBoxObserver() {
if (viewBoxObserver) {
viewBoxObserver.disconnect();
viewBoxObserver = null;
}
}
// ----------------- SVG POINTER MAPPING -----------------
function getViewBox(svg) {
const vb = svg.viewBox?.baseVal;
if (
vb &&
Number.isFinite(vb.x) &&
Number.isFinite(vb.y) &&
Number.isFinite(vb.width) &&
Number.isFinite(vb.height)
) {
return {
x: vb.x,
y: vb.y,
width: vb.width,
height: vb.height
};
}
const raw = (svg.getAttribute("viewBox") || "").trim();
const parts = raw.split(/[\s,]+/).map(Number);
if (
parts.length >= 4 &&
parts.every(Number.isFinite)
) {
return {
x: parts[0],
y: parts[1],
width: parts[2],
height: parts[3]
};
}
return null;
}
function getPreserveAspectRatio(svg) {
const raw = (
svg.getAttribute("preserveAspectRatio") || ""
).trim();
if (!raw) {
return {
align: "xMidYMid",
meetOrSlice: "meet"
};
}
const parts = raw.split(/\s+/);
const align = parts[0] || "xMidYMid";
const meetOrSlice = parts[1] || "meet";
return { align, meetOrSlice };
}
function clientToSvgPoint(svg, clientX, clientY) {
const rect = svg.getBoundingClientRect();
const vb = getViewBox(svg);
if (!vb || !rect.width || !rect.height) {
return { x: 0, y: 0 };
}
const par = getPreserveAspectRatio(svg);
if (par.align === "none") {
const sx = vb.width / rect.width;
const sy = vb.height / rect.height;
return {
x: vb.x + (clientX - rect.left) * sx,
y: vb.y + (clientY - rect.top) * sy
};
}
const scaleX = rect.width / vb.width;
const scaleY = rect.height / vb.height;
const scale = par.meetOrSlice === "slice"
? Math.max(scaleX, scaleY)
: Math.min(scaleX, scaleY);
const renderedWidth = vb.width * scale;
const renderedHeight = vb.height * scale;
let offsetX = 0;
let offsetY = 0;
if (par.align.includes("xMid")) {
offsetX = (rect.width - renderedWidth) / 2;
} else if (par.align.includes("xMax")) {
offsetX = rect.width - renderedWidth;
}
if (par.align.includes("YMid")) {
offsetY = (rect.height - renderedHeight) / 2;
} else if (par.align.includes("YMax")) {
offsetY = rect.height - renderedHeight;
}
const localX = clientX - rect.left - offsetX;
const localY = clientY - rect.top - offsetY;
return {
x: vb.x + (localX / scale),
y: vb.y + (localY / scale)
};
}
function getUnitsPerPx(svg) {
const rect = svg.getBoundingClientRect();
const vb = getViewBox(svg);
if (!vb || !rect.width || !rect.height) {
return { x: 1, y: 1 };
}
const par = getPreserveAspectRatio(svg);
if (par.align === "none") {
return {
x: vb.width / rect.width,
y: vb.height / rect.height
};
}
const scaleX = rect.width / vb.width;
const scaleY = rect.height / vb.height;
const scale = par.meetOrSlice === "slice"
? Math.max(scaleX, scaleY)
: Math.min(scaleX, scaleY);
return {
x: 1 / scale,
y: 1 / scale
};
}
// ----------------- MAATVOERING SYNC -----------------
function forceClickThrough(el) {
if (!el) return;
el.setAttribute("pointer-events", "none");
if (el.style) {
el.style.pointerEvents = "none";
}
}
function syncMaatvoering() {
const svg = getSvg();
if (!svg || !cloneRoot) return;
// Verwijder uitsluitend de oude vergrote maatvoering
cloneRoot.querySelectorAll(
`[id="${PREFIX}${MAATVOERING_ID}"]`
).forEach(el => el.remove());
// Zoek de originele maatvoering buiten de loupe
const original = Array.from(svg.children).find(
el => el.id === MAATVOERING_ID
);
if (!original) return;
if (
original.getAttribute("display") === "none" ||
original.style.display === "none"
) {
return;
}
if (!original.childElementCount) return;
const copy = original.cloneNode(true);
copy.setAttribute("id", PREFIX + MAATVOERING_ID);
copy.setAttribute("data-zoom-overlay", "1");
forceClickThrough(copy);
copy.querySelectorAll("*").forEach(node => {
if (node.hasAttribute("id")) {
node.setAttribute(
"id",
PREFIX + node.getAttribute("id")
);
}
forceClickThrough(node);
});
// Maatvoering boven alle vergrote SVG-elementen
cloneRoot.appendChild(copy);
}
function isMaatvoeringNode(node) {
if (!node) return false;
const el = node.nodeType === 1
? node
: node.parentElement;
if (!el) return false;
return (
el.id === MAATVOERING_ID ||
!!el.closest?.(`#${MAATVOERING_ID}`)
);
}
// ----------------- INIT LOUPE -----------------
function initLoupeIfNeeded() {
const svg = getSvg();
if (!svg) return;
if (!baseConditionsOk()) return;
if (loupeInitialized) return;
loupeInitialized = true;
let defs = svg.querySelector("defs");
if (!defs) {
defs = document.createElementNS(NS, "defs");
svg.insertBefore(defs, svg.firstChild);
}
const clipPath = document.createElementNS(NS, "clipPath");
clipPath.setAttribute("id", "zoomClip");
clipPath.setAttribute("clipPathUnits", "userSpaceOnUse");
clipEllipse = document.createElementNS(NS, "ellipse");
clipEllipse.setAttribute("cx", 0);
clipEllipse.setAttribute("cy", 0);
clipEllipse.setAttribute("rx", 1);
clipEllipse.setAttribute("ry", 1);
clipPath.appendChild(clipEllipse);
defs.appendChild(clipPath);
// ----------------- LENS GROUP -----------------
zoomGroup = document.createElementNS(NS, "g");
zoomGroup.setAttribute("id", "zoomLens");
zoomGroup.setAttribute("clip-path", "url(#zoomClip)");
zoomGroup.setAttribute("data-zoom-overlay", "1");
zoomGroup.setAttribute("pointer-events", "none");
zoomGroup.style.pointerEvents = "none";
zoomGroup.style.display = "none";
svg.appendChild(zoomGroup);
// ----------------- DEKKENDE ACHTERGROND -----------------
// Voorkomt dat de originele, kleine maatlijnen
// door de vergrote SVG heen zichtbaar blijven.
lensBackground = document.createElementNS(NS, "rect");
lensBackground.setAttribute("x", -1);
lensBackground.setAttribute("y", -1);
lensBackground.setAttribute("width", 2);
lensBackground.setAttribute("height", 2);
lensBackground.setAttribute("fill", LENS_BACKGROUND);
lensBackground.setAttribute("data-zoom-overlay", "1");
lensBackground.setAttribute("pointer-events", "none");
zoomGroup.appendChild(lensBackground);
// ----------------- SCALE GROUP -----------------
scaleGroup = document.createElementNS(NS, "g");
scaleGroup.setAttribute("data-zoom-overlay", "1");
scaleGroup.setAttribute("pointer-events", "none");
scaleGroup.setAttribute("transform-box", "view-box");
scaleGroup.setAttribute("transform-origin", "0 0");
scaleGroup.style.pointerEvents = "none";
zoomGroup.appendChild(scaleGroup);
// ----------------- LENS BORDER -----------------
border = document.createElementNS(NS, "ellipse");
border.setAttribute("id", "zoomBorder");
border.setAttribute("data-zoom-overlay", "1");
border.setAttribute("fill", "none");
border.setAttribute("stroke", "white");
border.setAttribute("stroke-width", 2);
border.setAttribute("pointer-events", "none");
border.style.pointerEvents = "none";
border.style.display = "none";
svg.appendChild(border);
// ----------------- REBUILD CLONE -----------------
function rebuildClone() {
if (!scaleGroup) return;
if (syncObserver) {
syncObserver.disconnect();
}
scaleGroup.innerHTML = "";
const originals = Array.from(svg.children).filter(el => {
const tag = el.tagName.toLowerCase();
if (tag === "defs") return false;
if (
el.id === "zoomLens" ||
el.id === "zoomBorder"
) {
return false;
}
// Maatvoering wordt afzonderlijk gesynchroniseerd
if (el.id === MAATVOERING_ID) return false;
if (
el.getAttribute("data-zoom-overlay") === "1"
) {
return false;
}
return true;
});
cloneRoot = document.createElementNS(NS, "g");
cloneRoot.setAttribute("data-zoom-root", "1");
cloneRoot.setAttribute("pointer-events", "none");
cloneRoot.style.pointerEvents = "none";
scaleGroup.appendChild(cloneRoot);
originals.forEach(el => {
cloneRoot.appendChild(el.cloneNode(true));
});
cloneRoot.querySelectorAll("*").forEach(node => {
forceClickThrough(node);
});
const idMap = new Map();
cloneRoot.querySelectorAll("[id]").forEach(node => {
const oldId = node.getAttribute("id");
const newId = PREFIX + oldId;
idMap.set(oldId, newId);
node.setAttribute("id", newId);
});
const rewriteRefString = (s) => {
if (!s || typeof s !== "string") return s;
s = s.replace(
/url\(\s*#([^)]+?)\s*\)/g,
(m, id) => {
const mapped = idMap.get(id);
return mapped ? `url(#${mapped})` : m;
}
);
s = s.replace(
/#([A-Za-z_][\w:.-]*)/g,
(m, id) => {
const mapped = idMap.get(id);
return mapped ? `#${mapped}` : m;
}
);
return s;
};
const attrsToRewrite = [
"fill",
"stroke",
"filter",
"clip-path",
"mask",
"style",
"href"
];
cloneRoot.querySelectorAll("*").forEach(node => {
for (const a of attrsToRewrite) {
if (node.hasAttribute(a)) {
node.setAttribute(
a,
rewriteRefString(node.getAttribute(a))
);
}
}
const xh = node.getAttributeNS(XLINK, "href");
if (xh) {
node.setAttributeNS(
XLINK,
"xlink:href",
rewriteRefString(xh)
);
}
});
// Maatvoering als laatste toevoegen
syncMaatvoering();
attachSyncObserver();
pendingRebuild = false;
}
const ATTRS_TO_SYNC = new Set([
"style",
"class",
"transform",
"opacity",
"display",
"visibility",
"filter",
"clip-path",
"mask",
"x",
"y",
"cx",
"cy",
"d",
"points",
"fill",
"stroke",
"stroke-width",
"fill-opacity",
"stroke-opacity",
"x1",
"x2",
"y1",
"y2",
"font-size"
]);
function getCloneBySourceId(sourceId) {
if (!cloneRoot) return null;
const zId = PREFIX + sourceId;
return cloneRoot.querySelector(
`#${cssEscapeSafe(zId)}`
);
}
// ----------------- SYNC OBSERVER -----------------
function attachSyncObserver() {
if (syncObserver) {
syncObserver.disconnect();
}
syncObserver = new MutationObserver((mutations) => {
if (syncing) return;
syncing = true;
let maatvoeringChanged = false;
try {
for (const m of mutations) {
// Wijzigingen binnen de loupe negeren
const targetEl = m.target.nodeType === 1
? m.target
: m.target.parentElement;
if (
targetEl?.closest?.('[data-zoom-overlay="1"]')
) {
continue;
}
// Wijzigingen aan maatvoering apart behandelen
if (isMaatvoeringNode(m.target)) {
maatvoeringChanged = true;
continue;
}
if (m.type === "childList") {
const changedNodes = [
...m.addedNodes,
...m.removedNodes
];
const changedMaatvoering = changedNodes.some(
node => isMaatvoeringNode(node)
);
if (changedMaatvoering) {
maatvoeringChanged = true;
}
const otherChanges = changedNodes.some(node => {
return !isMaatvoeringNode(node);
});
if (otherChanges) {
pendingRebuild = true;
}
continue;
}
// Reguliere SVG-attributen synchroniseren
if (m.type === "attributes") {
const src = m.target;
const srcId = src?.getAttribute?.("id");
if (!srcId) continue;
const attr = m.attributeName;
if (!ATTRS_TO_SYNC.has(attr)) continue;
const cloneEl = getCloneBySourceId(srcId);
if (!cloneEl) continue;
const val = src.getAttribute(attr);
if (val === null) {
cloneEl.removeAttribute(attr);
} else {
cloneEl.setAttribute(attr, val);
}
forceClickThrough(cloneEl);
}
}
// Maatvoering onmiddellijk synchroniseren
if (maatvoeringChanged) {
syncMaatvoering();
}
} finally {
syncing = false;
}
});
syncObserver.observe(svg, {
subtree: true,
attributes: true,
childList: true,
characterData: true,
attributeFilter: Array.from(ATTRS_TO_SYNC)
});
}
rebuildClone();
rebuildTimer = setInterval(() => {
if (!pendingRebuild) return;
const idle = (Date.now() - lastPointerMoveAt) > 200;
if (idle || !mouseOnSvg) {
rebuildClone();
}
}, 150);
attachViewBoxObserverIfNeeded();
}
// ----------------- LENS UPDATE -----------------
function updateLensFromEvent(e) {
const svg = getSvg();
if (
!svg ||
!clipEllipse ||
!border ||
!scaleGroup ||
!e
) {
return;
}
lastPointerMoveAt = Date.now();
const unitsPerPx = getUnitsPerPx(svg);
const lensRadiusPx = LENS_DIAMETER_PX / 2;
const rx = lensRadiusPx * unitsPerPx.x;
const ry = lensRadiusPx * unitsPerPx.y;
const p = clientToSvgPoint(
svg,
e.clientX,
e.clientY
);
// Clip positioneren
clipEllipse.setAttribute("cx", p.x);
clipEllipse.setAttribute("cy", p.y);
clipEllipse.setAttribute("rx", rx);
clipEllipse.setAttribute("ry", ry);
// Dekkende achtergrond positioneren
if (lensBackground) {
lensBackground.setAttribute("x", p.x - rx);
lensBackground.setAttribute("y", p.y - ry);
lensBackground.setAttribute("width", rx * 2);
lensBackground.setAttribute("height", ry * 2);
}
// Rand positioneren
border.setAttribute("cx", p.x);
border.setAttribute("cy", p.y);
border.setAttribute("rx", rx);
border.setAttribute("ry", ry);
// Vergroting positioneren
scaleGroup.setAttribute(
"transform",
`translate(${p.x} ${p.y}) scale(${SCALE_FACTOR}) translate(${-p.x} ${-p.y})`
);
}
function scheduleLensUpdate(e) {
lastEvt = e;
if (raf) return;
raf = requestAnimationFrame(() => {
raf = 0;
if (!loupeInitialized) return;
if (!baseConditionsOk()) {
cleanupLoupe();
return;
}
if (activeConditionsOk()) {
showLens();
updateLensFromEvent(lastEvt);
} else {
hideLens();
}
});
}
// ----------------- CONTROL EVALUATION -----------------
function evaluate() {
if (vvuOk()) {
attachViewBoxObserverIfNeeded();
} else {
detachViewBoxObserver();
}
if (loupeInitialized && !baseConditionsOk()) {
cleanupLoupe();
}
if (loupeInitialized) {
if (activeConditionsOk()) {
showLens();
} else {
hideLens();
}
}
}
// ----------------- WIRE EVENTS -----------------
function wire() {
const svg = getSvg();
if (!svg) return;
svg.addEventListener("mouseenter", (e) => {
if (e.target !== svg) return;
mouseOnSvg = true;
evaluate();
if (activeConditionsOk()) {
initLoupeIfNeeded();
showLens();
updateLensFromEvent(e);
}
}, { capture: true });
svg.addEventListener("mouseleave", (e) => {
if (e.target !== svg) return;
mouseOnSvg = false;
hideLens();
}, { capture: true });
svg.addEventListener("pointermove", (e) => {
if (!loupeInitialized) return;
scheduleLensUpdate(e);
}, {
passive: true,
capture: true
});
document.addEventListener("change", (e) => {
const t = e.target;
if (!(t instanceof HTMLElement)) return;
if (
t.matches(VAKKEN_SELECTOR) ||
t.matches(VVU_SELECTOR)
) {
evaluate();
if (activeConditionsOk()) {
initLoupeIfNeeded();
showLens();
}
}
});
}
wire();
})();
/// LOUPE #ALLE-VAKKEN ////
(() => {
const SVG_ID = "alle-vakken";
// Form conditions
const VAKKEN_SELECTOR = 'input[type="radio"][name="form_fields[vakken]"]';
const VVU_SELECTOR = 'select[id^="form-field-"][id*="VVU"]';
const ALLOWED_VVU_VALUES = new Set([
"linksschuivend",
"rechtsschuivend",
"linksrechtsschuivend",
]);
const MIN_VIEWBOX_WIDTH_EXCLUSIVE = 744;
// Loupe config
const LENS_DIAMETER_PX = 200;
const SCALE_FACTOR = 2;
const NS = "http://www.w3.org/2000/svg";
const XLINK = "http://www.w3.org/1999/xlink";
const PREFIX = "z_";
// control
let mouseOnSvg = false;
let loupeInitialized = false;
// observers
let viewBoxObserver = null;
// loupe internals
let syncObserver = null;
let zoomGroup = null;
let scaleGroup = null;
let border = null;
let clipEllipse = null;
let cloneRoot = null;
// deferred rebuild
let pendingRebuild = false;
let lastPointerMoveAt = 0;
let rebuildTimer = null;
let syncing = false;
// pointermove rAF throttle
let raf = 0;
let lastEvt = null;
function cssEscapeSafe(id) {
if (window.CSS && CSS.escape) return CSS.escape(id);
return id.replace(/([ #;?%&,.+*~\':"!^$[\]()=>|\/@])/g, "\\$1");
}
function getSvg() {
return document.getElementById(SVG_ID);
}
// ----------------- CONDITIONS -----------------
function vvuOk() {
const selects = Array.from(document.querySelectorAll(VVU_SELECTOR));
if (!selects.length) return false;
return selects.some(sel => ALLOWED_VVU_VALUES.has(String(sel.value || "").trim().toLowerCase()));
}
function vakkenOk() {
return !!document.querySelector(`${VAKKEN_SELECTOR}:checked`);
}
function viewBoxWidthOk(svg) {
if (!svg) return false;
const vb = svg.viewBox?.baseVal;
if (vb && Number.isFinite(vb.width)) return vb.width > MIN_VIEWBOX_WIDTH_EXCLUSIVE;
const vbAttr = svg.getAttribute("viewBox") || "";
const parts = vbAttr.trim().split(/[\s,]+/).map(Number);
if (parts.length >= 3 && Number.isFinite(parts[2])) return parts[2] > MIN_VIEWBOX_WIDTH_EXCLUSIVE;
return false;
}
function baseConditionsOk() {
const svg = getSvg();
return !!svg && vvuOk() && vakkenOk() && viewBoxWidthOk(svg);
}
function activeConditionsOk() {
return baseConditionsOk() && mouseOnSvg;
}
// ----------------- SHOW/HIDE/CLEANUP -----------------
function hideLens() {
if (zoomGroup) zoomGroup.style.display = "none";
if (border) border.style.display = "none";
}
function showLens() {
if (zoomGroup) zoomGroup.style.display = "";
if (border) border.style.display = "";
}
function cleanupLoupe() {
const svg = getSvg();
if (!svg) return;
hideLens();
if (syncObserver) {
syncObserver.disconnect();
syncObserver = null;
}
if (rebuildTimer) {
clearInterval(rebuildTimer);
rebuildTimer = null;
}
const oldZoom = svg.querySelector('g#zoomLens');
const oldBorder = svg.querySelector('ellipse#zoomBorder');
const oldClip = svg.querySelector('defs #zoomClip');
if (oldZoom) oldZoom.remove();
if (oldBorder) oldBorder.remove();
if (oldClip) oldClip.remove();
zoomGroup = null;
scaleGroup = null;
border = null;
clipEllipse = null;
cloneRoot = null;
pendingRebuild = false;
lastPointerMoveAt = 0;
syncing = false;
loupeInitialized = false;
}
// ----------------- VIEWBOX OBSERVER -----------------
function attachViewBoxObserverIfNeeded() {
const svg = getSvg();
if (!svg) return;
if (viewBoxObserver) viewBoxObserver.disconnect();
viewBoxObserver = new MutationObserver((muts) => {
for (const m of muts) {
if (m.type === "attributes" && m.attributeName === "viewBox") {
if (!baseConditionsOk()) cleanupLoupe();
}
}
});
viewBoxObserver.observe(svg, { attributes: true, attributeFilter: ["viewBox"] });
}
function detachViewBoxObserver() {
if (viewBoxObserver) {
viewBoxObserver.disconnect();
viewBoxObserver = null;
}
}
// ----------------- SVG POINTER MAPPING -----------------
function getViewBox(svg) {
const vb = svg.viewBox?.baseVal;
if (vb && Number.isFinite(vb.x) && Number.isFinite(vb.y) && Number.isFinite(vb.width) && Number.isFinite(vb.height)) {
return { x: vb.x, y: vb.y, width: vb.width, height: vb.height };
}
const raw = (svg.getAttribute("viewBox") || "").trim();
const parts = raw.split(/[\s,]+/).map(Number);
if (parts.length >= 4 && parts.every(Number.isFinite)) {
return { x: parts[0], y: parts[1], width: parts[2], height: parts[3] };
}
return null;
}
function getPreserveAspectRatio(svg) {
const raw = (svg.getAttribute("preserveAspectRatio") || "").trim();
if (!raw) {
return { align: "xMidYMid", meetOrSlice: "meet" };
}
const parts = raw.split(/\s+/);
const align = parts[0] || "xMidYMid";
const meetOrSlice = parts[1] || "meet";
return { align, meetOrSlice };
}
function clientToSvgPoint(svg, clientX, clientY) {
const rect = svg.getBoundingClientRect();
const vb = getViewBox(svg);
if (!vb || !rect.width || !rect.height) {
return { x: 0, y: 0 };
}
const par = getPreserveAspectRatio(svg);
if (par.align === "none") {
const sx = vb.width / rect.width;
const sy = vb.height / rect.height;
return {
x: vb.x + (clientX - rect.left) * sx,
y: vb.y + (clientY - rect.top) * sy
};
}
const scaleX = rect.width / vb.width;
const scaleY = rect.height / vb.height;
const scale = par.meetOrSlice === "slice"
? Math.max(scaleX, scaleY)
: Math.min(scaleX, scaleY);
const renderedWidth = vb.width * scale;
const renderedHeight = vb.height * scale;
let offsetX = 0;
let offsetY = 0;
if (par.align.includes("xMid")) offsetX = (rect.width - renderedWidth) / 2;
else if (par.align.includes("xMax")) offsetX = rect.width - renderedWidth;
if (par.align.includes("YMid")) offsetY = (rect.height - renderedHeight) / 2;
else if (par.align.includes("YMax")) offsetY = rect.height - renderedHeight;
const localX = clientX - rect.left - offsetX;
const localY = clientY - rect.top - offsetY;
return {
x: vb.x + (localX / scale),
y: vb.y + (localY / scale)
};
}
function getUnitsPerPx(svg) {
const rect = svg.getBoundingClientRect();
const vb = getViewBox(svg);
if (!vb || !rect.width || !rect.height) {
return { x: 1, y: 1 };
}
const par = getPreserveAspectRatio(svg);
if (par.align === "none") {
return {
x: vb.width / rect.width,
y: vb.height / rect.height
};
}
const scaleX = rect.width / vb.width;
const scaleY = rect.height / vb.height;
const scale = par.meetOrSlice === "slice"
? Math.max(scaleX, scaleY)
: Math.min(scaleX, scaleY);
return {
x: 1 / scale,
y: 1 / scale
};
}
// ----------------- INIT LOUPE -----------------
function initLoupeIfNeeded() {
const svg = getSvg();
if (!svg) return;
if (!baseConditionsOk()) return;
if (loupeInitialized) return;
loupeInitialized = true;
let defs = svg.querySelector("defs");
if (!defs) {
defs = document.createElementNS(NS, "defs");
svg.insertBefore(defs, svg.firstChild);
}
const clipPath = document.createElementNS(NS, "clipPath");
clipPath.setAttribute("id", "zoomClip");
clipPath.setAttribute("clipPathUnits", "userSpaceOnUse");
clipEllipse = document.createElementNS(NS, "ellipse");
clipEllipse.setAttribute("cx", 0);
clipEllipse.setAttribute("cy", 0);
clipEllipse.setAttribute("rx", 1);
clipEllipse.setAttribute("ry", 1);
clipPath.appendChild(clipEllipse);
defs.appendChild(clipPath);
zoomGroup = document.createElementNS(NS, "g");
zoomGroup.setAttribute("id", "zoomLens");
zoomGroup.setAttribute("clip-path", "url(#zoomClip)");
zoomGroup.setAttribute("data-zoom-overlay", "1");
zoomGroup.setAttribute("pointer-events", "none");
zoomGroup.style.pointerEvents = "none";
zoomGroup.style.display = "none";
svg.appendChild(zoomGroup);
scaleGroup = document.createElementNS(NS, "g");
scaleGroup.setAttribute("data-zoom-overlay", "1");
scaleGroup.setAttribute("pointer-events", "none");
scaleGroup.style.pointerEvents = "none";
scaleGroup.setAttribute("transform-box", "view-box");
scaleGroup.setAttribute("transform-origin", "0 0");
zoomGroup.appendChild(scaleGroup);
border = document.createElementNS(NS, "ellipse");
border.setAttribute("id", "zoomBorder");
border.setAttribute("data-zoom-overlay", "1");
border.setAttribute("fill", "none");
border.setAttribute("stroke", "white");
border.setAttribute("stroke-width", 2);
border.setAttribute("pointer-events", "none");
border.style.pointerEvents = "none";
border.style.display = "none";
svg.appendChild(border);
function rebuildClone() {
if (!scaleGroup) return;
if (syncObserver) syncObserver.disconnect();
scaleGroup.innerHTML = "";
const originals = Array.from(svg.children).filter(el => {
const tag = el.tagName.toLowerCase();
if (tag === "defs") return false;
if (el.id === "zoomLens" || el.id === "zoomBorder") return false;
return true;
});
cloneRoot = document.createElementNS(NS, "g");
cloneRoot.setAttribute("data-zoom-root", "1");
cloneRoot.setAttribute("pointer-events", "none");
cloneRoot.style.pointerEvents = "none";
scaleGroup.appendChild(cloneRoot);
originals.forEach(el => cloneRoot.appendChild(el.cloneNode(true)));
cloneRoot.querySelectorAll("*").forEach(node => {
node.setAttribute("pointer-events", "none");
if (node.style) node.style.pointerEvents = "none";
});
const idMap = new Map();
cloneRoot.querySelectorAll("[id]").forEach(node => {
const oldId = node.getAttribute("id");
const newId = PREFIX + oldId;
idMap.set(oldId, newId);
node.setAttribute("id", newId);
});
const rewriteRefString = (s) => {
if (!s || typeof s !== "string") return s;
s = s.replace(/url\(\s*#([^)]+?)\s*\)/g, (m, id) => {
const mapped = idMap.get(id);
return mapped ? `url(#${mapped})` : m;
});
s = s.replace(/#([A-Za-z_][\w:.-]*)/g, (m, id) => {
const mapped = idMap.get(id);
return mapped ? `#${mapped}` : m;
});
return s;
};
const attrsToRewrite = ["fill","stroke","filter","clip-path","mask","style","href"];
cloneRoot.querySelectorAll("*").forEach(node => {
for (const a of attrsToRewrite) {
if (node.hasAttribute(a)) node.setAttribute(a, rewriteRefString(node.getAttribute(a)));
}
const xh = node.getAttributeNS(XLINK, "href");
if (xh) node.setAttributeNS(XLINK, "xlink:href", rewriteRefString(xh));
});
attachSyncObserver();
pendingRebuild = false;
}
const ATTRS_TO_SYNC = new Set([
"style","class","transform","opacity","display","visibility",
"filter","clip-path","mask",
"x","y","cx","cy","d","points",
"fill","stroke","stroke-width","fill-opacity","stroke-opacity"
]);
function getCloneBySourceId(sourceId) {
if (!cloneRoot) return null;
const zId = PREFIX + sourceId;
return cloneRoot.querySelector(`#${cssEscapeSafe(zId)}`);
}
function forceClickThrough(el) {
if (!el) return;
el.setAttribute("pointer-events", "none");
el.style.pointerEvents = "none";
}
function attachSyncObserver() {
if (syncObserver) syncObserver.disconnect();
syncObserver = new MutationObserver((mutations) => {
if (syncing) return;
syncing = true;
for (const m of mutations) {
if (m.target?.closest?.('[data-zoom-overlay="1"]')) continue;
if (m.type === "attributes") {
const src = m.target;
const srcId = src?.getAttribute?.("id");
if (!srcId) continue;
const attr = m.attributeName;
if (!ATTRS_TO_SYNC.has(attr)) continue;
const cloneEl = getCloneBySourceId(srcId);
if (!cloneEl) continue;
const val = src.getAttribute(attr);
if (val === null) cloneEl.removeAttribute(attr);
else cloneEl.setAttribute(attr, val);
forceClickThrough(cloneEl);
}
if (m.type === "childList") {
pendingRebuild = true;
}
}
syncing = false;
});
syncObserver.observe(svg, {
subtree: true,
attributes: true,
childList: true,
attributeFilter: Array.from(ATTRS_TO_SYNC)
});
}
rebuildClone();
rebuildTimer = setInterval(() => {
if (!pendingRebuild) return;
const idle = (Date.now() - lastPointerMoveAt) > 200;
if (idle || !mouseOnSvg) rebuildClone();
}, 150);
attachViewBoxObserverIfNeeded();
}
// ----------------- LENS UPDATE -----------------
function updateLensFromEvent(e) {
const svg = getSvg();
if (!svg || !clipEllipse || !border || !scaleGroup) return;
lastPointerMoveAt = Date.now();
const unitsPerPx = getUnitsPerPx(svg);
const lensRadiusPx = LENS_DIAMETER_PX / 2;
const rx = lensRadiusPx * unitsPerPx.x;
const ry = lensRadiusPx * unitsPerPx.y;
const p = clientToSvgPoint(svg, e.clientX, e.clientY);
clipEllipse.setAttribute("cx", p.x);
clipEllipse.setAttribute("cy", p.y);
clipEllipse.setAttribute("rx", rx);
clipEllipse.setAttribute("ry", ry);
border.setAttribute("cx", p.x);
border.setAttribute("cy", p.y);
border.setAttribute("rx", rx);
border.setAttribute("ry", ry);
scaleGroup.setAttribute(
"transform",
`translate(${p.x} ${p.y}) scale(${SCALE_FACTOR}) translate(${-p.x} ${-p.y})`
);
}
function scheduleLensUpdate(e) {
lastEvt = e;
if (raf) return;
raf = requestAnimationFrame(() => {
raf = 0;
if (!loupeInitialized) return;
if (!baseConditionsOk()) {
cleanupLoupe();
return;
}
if (activeConditionsOk()) {
showLens();
updateLensFromEvent(lastEvt);
} else {
hideLens();
}
});
}
// ----------------- CONTROL EVALUATION -----------------
function evaluate() {
if (vvuOk()) attachViewBoxObserverIfNeeded();
else detachViewBoxObserver();
if (loupeInitialized && !baseConditionsOk()) cleanupLoupe();
if (loupeInitialized) {
if (activeConditionsOk()) showLens();
else hideLens();
}
}
// ----------------- WIRE EVENTS -----------------
function wire() {
const svg = getSvg();
if (!svg) return;
svg.addEventListener("mouseenter", (e) => {
mouseOnSvg = true;
evaluate();
if (activeConditionsOk()) {
initLoupeIfNeeded();
showLens();
updateLensFromEvent(e);
}
}, { capture: true });
svg.addEventListener("mouseleave", () => {
mouseOnSvg = false;
hideLens();
}, { capture: true });
svg.addEventListener("pointermove", (e) => {
if (!loupeInitialized) return;
scheduleLensUpdate(e);
}, { passive: true, capture: true });
document.addEventListener("change", (e) => {
const t = e.target;
if (!(t instanceof HTMLElement)) return;
if (t.matches(VAKKEN_SELECTOR) || t.matches(VVU_SELECTOR)) {
evaluate();
if (activeConditionsOk()) {
initLoupeIfNeeded();
showLens();
}
}
});
}
wire();
})();
//// RECYCLAAT (kg) ////
(function () {
const FACTOR = 0.95 * 0.70;
// Boorgat parameters
const BOORGAT_DIAMETER_MM = 17;
const BOORGAT_RADIUS_MM = BOORGAT_DIAMETER_MM / 2;
const BOORGAT_AREA_MM2 = Math.PI * BOORGAT_RADIUS_MM * BOORGAT_RADIUS_MM;
const BOORGAT_COUNT_BY_VAK = { 1: 4, 2: 6, 3: 8, 4: 10, 5: 12 };
function $(sel) { return document.querySelector(sel); }
function $all(sel) { return Array.from(document.querySelectorAll(sel)); }
// ---------------- SERVER CART TOTAL ----------------
let lastCartKg = 0;
let lastCartFetchTs = 0;
async function fetchCartKgFromServer() {
try {
const res = await fetch('/wp-admin/admin-ajax.php?action=dts_recyclaat_total', { credentials: 'same-origin' });
const json = await res.json();
const kg = json && json.success && json.data ? Number(json.data.kg) : 0;
lastCartKg = isFinite(kg) ? kg : 0;
lastCartFetchTs = Date.now();
return lastCartKg;
} catch {
return lastCartKg; // fallback: laatst bekende waarde
}
}
// ---------------- CONDITIONS ----------------
function isKleurZSelectedIfPresent() {
// Op productpagina aanwezig; op cart/checkout meestal niet.
const r = document.querySelector('input[name="form_fields[Kleur]"]:checked');
if (!r) return true; // als niet aanwezig: local regel niet blokkeren (maar local calc zal toch 0 zijn zonder inputs)
return (r.value || '') === 'Z';
}
function getSelectedVakNumber() {
const r = document.querySelector('input[name="form_fields[vakken]"]:checked');
const m = r?.value?.match(/^(\d+)/);
return m ? parseInt(m[1], 10) : null;
}
function hasVakkenSelection() {
return !!document.querySelector('input[name="form_fields[vakken]"]:checked');
}
// ---------------- SVG DISPLAY CHECK (STRICT + ANCESTOR) ----------------
function hasDisplayNoneInAncestors(el) {
let cur = el;
while (cur && cur.nodeType === 1) {
const d = (cur.getAttribute?.('display') || '').toLowerCase();
if (d === 'none') return true;
if ((cur.tagName || '').toLowerCase() === 'svg') break;
cur = cur.parentElement;
}
return false;
}
function isDisplayBlock(el) {
if (!el) return false;
if (hasDisplayNoneInAncestors(el)) return false;
return (el.getAttribute?.('display') || '').toLowerCase() === 'block';
}
// ---------------- FILTERS ----------------
function idHasBoorgat(el) {
const id = (el?.id || '').toLowerCase();
return id.includes('boorgat');
}
// ---------------- GEOMETRY ----------------
function pathAreaMm2(pathEl) {
const len = pathEl.getTotalLength();
if (!isFinite(len) || len <= 0) return 0;
const n = Math.min(6000, Math.max(800, Math.ceil(len / 0.5)));
let area2 = 0;
const f = pathEl.getPointAtLength(0);
let p = f;
for (let i = 1; i <= n; i++) {
const q = pathEl.getPointAtLength((i / n) * len);
area2 += (p.x * q.y - q.x * p.y);
p = q;
}
area2 += (p.x * f.y - f.x * p.y);
return Math.abs(area2) / 2;
}
function parseSvgPoints(str) {
const nums = (str || '')
.trim()
.replace(/,/g, ' ')
.split(/\s+/)
.map(Number)
.filter(n => Number.isFinite(n));
const pts = [];
for (let i = 0; i + 1 < nums.length; i += 2) pts.push({ x: nums[i], y: nums[i + 1] });
return pts;
}
function polygonArea(pts) {
let a = 0;
const n = pts.length;
for (let i = 0; i < n; i++) {
const p = pts[i];
const q = pts[(i + 1) % n];
a += (p.x * q.y - q.x * p.y);
}
return Math.abs(a) / 2;
}
function spanAtX(pts, X) {
const ys = [];
const n = pts.length;
for (let i = 0; i < n; i++) {
const a = pts[i];
const b = pts[(i + 1) % n];
if (a.x === b.x) continue;
const xmin = Math.min(a.x, b.x);
const xmax = Math.max(a.x, b.x);
if (X < xmin || X >= xmax) continue;
const t = (X - a.x) / (b.x - a.x);
const y = a.y + t * (b.y - a.y);
if (Number.isFinite(y)) ys.push(y);
}
if (ys.length < 2) return 0;
ys.sort((a, b) => a - b);
let span = 0;
for (let i = 0; i + 1 < ys.length; i += 2) {
span += Math.max(0, ys[i + 1] - ys[i]);
}
return span;
}
function pathToPoints(pathEl) {
const len = pathEl.getTotalLength();
if (!isFinite(len) || len <= 0) return [];
const n = Math.min(6000, Math.max(800, Math.ceil(len / 0.5)));
const pts = [];
for (let i = 0; i < n; i++) {
const p = pathEl.getPointAtLength((i / n) * len);
pts.push({ x: p.x, y: p.y });
}
if (pts.length) pts.push({ x: pts[0].x, y: pts[0].y });
return pts;
}
function groupAreaMm2(g) {
if (!g || idHasBoorgat(g)) return 0;
let s = 0;
g.querySelectorAll('path,rect,polygon,polyline').forEach(e => {
if (idHasBoorgat(e)) return;
const t = (e.tagName || '').toLowerCase();
if (t === 'path') s += pathAreaMm2(e);
else if (t === 'rect') {
const w = parseFloat(e.getAttribute('width')) || 0;
const h = parseFloat(e.getAttribute('height')) || 0;
s += Math.abs(w * h);
} else if (t === 'polygon' || t === 'polyline') {
const pts = parseSvgPoints(e.getAttribute('points'));
if (pts.length >= 3) s += polygonArea(pts);
}
});
return s;
}
// ---------------- ACTIVE PROFILE GROUP ----------------
function getActiveProfileGroup() {
// Toegevoegd: KVTPKU-dorpel en KVTPKI-dorpel
for (const id of ['BIV-dorpel', 'BUVD-dorpel', 'KVT-dorpel', 'HS-dorpel', 'KVTPKU-dorpel', 'KVTPKI-dorpel']) {
const g = document.getElementById(id);
if (isDisplayBlock(g)) return g;
}
return null;
}
function getActiveDorpelAreaMm2() {
const g = getActiveProfileGroup();
const p = g?.querySelector('path[id*="_x5F_dorpel"]');
return p ? pathAreaMm2(p) : 0;
}
function getActiveNeutPath() {
const g = getActiveProfileGroup();
return g?.querySelector('path[id*="_x5F_neut"]') || null;
}
// ---------------- VAKKEN area ----------------
function getSelectedVakkenAreaMm2() {
const n = getSelectedVakNumber();
if (!n) return 0;
const root = document.getElementById('alle-vakken');
if (!root) return 0;
const sel = `g[id^="vak-${CSS.escape(String(n))}"]`;
const groups = Array.from(root.querySelectorAll(sel))
.filter(isDisplayBlock)
.filter(g => !idHasBoorgat(g));
const map = new Map();
groups.forEach(g => map.set(g.id, g));
return Array.from(map.values()).reduce((sum, g) => sum + groupAreaMm2(g), 0);
}
// ---------------- NEUT average height ----------------
function getNeutAverageHeightMm() {
const p = getActiveNeutPath();
if (!p) return 0;
const pts = pathToPoints(p);
if (pts.length < 4) return 0;
let minX = Infinity, maxX = -Infinity;
for (const q of pts) {
if (q.x < minX) minX = q.x;
if (q.x > maxX) maxX = q.x;
}
if (!isFinite(minX) || !isFinite(maxX) || maxX <= minX) return 0;
const SCAN = 200;
const EPS = 1e-4;
let xLeft = null, xRight = null;
for (let i = 0; i < SCAN; i++) {
const t = (i + 0.5) / SCAN;
const X = minX + t * (maxX - minX);
if (spanAtX(pts, X) > EPS) { xLeft = X; break; }
}
for (let i = SCAN - 1; i >= 0; i--) {
const t = (i + 0.5) / SCAN;
const X = minX + t * (maxX - minX);
if (spanAtX(pts, X) > EPS) { xRight = X; break; }
}
if (xLeft == null || xRight == null || xRight <= xLeft) {
xLeft = minX; xRight = maxX;
}
const inset = Math.min(0.2, (xRight - xLeft) * 0.005);
xLeft += inset;
xRight -= inset;
const width = xRight - xLeft;
if (!isFinite(width) || width <= 0) return 0;
const STEPS = 60;
let sum = 0, count = 0;
for (let i = 0; i < STEPS; i++) {
const t = (i + 0.5) / STEPS;
const X = xLeft + t * width;
const h = spanAtX(pts, X);
if (h > EPS && isFinite(h)) { sum += h; count++; }
}
return count ? (sum / count) : 0;
}
function getBoorgatVolumePerStukMm3(h_avg) {
const n = getSelectedVakNumber();
const count = BOORGAT_COUNT_BY_VAK[n] || 0;
if (!count || !isFinite(h_avg) || h_avg <= 0) return 0;
return count * (BOORGAT_AREA_MM2 * h_avg);
}
// ---------------- RECT UNION (lood/kalk) ----------------
function rectToBox(r) {
const x = parseFloat(r.getAttribute('x')) || 0;
const y = parseFloat(r.getAttribute('y')) || 0;
const w = parseFloat(r.getAttribute('width')) || 0;
const h = parseFloat(r.getAttribute('height')) || 0;
let tx = 0, ty = 0;
let cur = r;
while (cur && cur.nodeType === 1) {
const tr = cur.getAttribute?.('transform') || '';
const m = tr.match(/translate\(\s*([-\d.]+)(?:[,\s]+([-\d.]+))?\s*\)/i);
if (m) {
tx += parseFloat(m[1]) || 0;
ty += (m[2] != null ? (parseFloat(m[2]) || 0) : 0);
}
if ((cur.tagName || '').toLowerCase() === 'svg') break;
cur = cur.parentElement;
}
const x0 = x + tx;
const y0 = y + ty;
return { x0, y0, x1: x0 + w, y1: y0 + h };
}
function unionAreaRectsMm2(rects) {
const boxes = (rects || []).map(rectToBox).filter(b => b.x1 > b.x0 && b.y1 > b.y0);
if (!boxes.length) return 0;
const xs = Array.from(new Set(boxes.flatMap(b => [b.x0, b.x1]))).sort((a,b)=>a-b);
let area = 0;
for (let i = 0; i < xs.length - 1; i++) {
const xA = xs[i], xB = xs[i + 1];
const dx = xB - xA;
if (dx <= 0) continue;
const intervals = [];
for (const b of boxes) {
if (b.x0 <= xA && b.x1 >= xB) intervals.push([b.y0, b.y1]);
}
if (!intervals.length) continue;
intervals.sort((a,b)=>a[0]-b[0]);
let covered = 0;
let [curY0, curY1] = intervals[0];
for (let k = 1; k < intervals.length; k++) {
const [y0, y1] = intervals[k];
if (y0 > curY1) {
covered += (curY1 - curY0);
curY0 = y0; curY1 = y1;
} else {
curY1 = Math.max(curY1, y1);
}
}
covered += (curY1 - curY0);
area += covered * dx;
}
return area;
}
function getLoodsponningAreaMm2() {
const ids = ['loodsponning-1', 'loodsponning-2', 'loodsponning-3'];
const rects = [];
ids.forEach(id => {
const g = document.getElementById(id);
if (!isDisplayBlock(g)) return;
g.querySelectorAll('rect').forEach(r => rects.push(r));
});
return unionAreaRectsMm2(rects);
}
function getKalkspHeightMm() {
const el = document.getElementById('form-field-dorpeldikte');
const dikte = parseFloat(el?.value);
return isFinite(dikte) && dikte > 0 ? (dikte + 29) : 0;
}
function getKalkspAreaMm2() {
const root = document.getElementById('alle-vakken') || document;
const groups = Array.from(root.querySelectorAll('g[id^="kalksp"]')).filter(isDisplayBlock);
const rects = [];
groups.forEach(g => g.querySelectorAll('rect').forEach(r => rects.push(r)));
return unionAreaRectsMm2(rects);
}
// ---------------- FORM INPUTS ----------------
function readInputs() {
const aantalGet = parseFloat(document.getElementById('form-field-aantal_get')?.value) || 0;
const aantalGesp = parseFloat(document.getElementById('form-field-aantal_gesp')?.value) || 0;
const len = parseFloat(document.getElementById('display-BIBUlengte')?.value) || 0;
const aantal = aantalGet + aantalGesp;
return { aantal, len };
}
// ---------------- LOCAL CALC ----------------
function calcKgLocal() {
// Local berekening alleen als kleur Z (als kleur input bestaat)
if (!isKleurZSelectedIfPresent()) return 0;
const { aantal, len } = readInputs();
if (!isFinite(aantal) || aantal <= 0) return 0;
if (!isFinite(len) || len <= 0) return 0;
// 1) DORPEL (PLUS)
const A_dorpel = getActiveDorpelAreaMm2();
const volDorpelMm3 = (aantal * len) * A_dorpel;
const kg_dorpel = (volDorpelMm3 / 1e6) * FACTOR;
// 2) NEUT (PLUS) minus boorgaten
const A_vak = getSelectedVakkenAreaMm2();
const h_avg = getNeutAverageHeightMm();
const volNeutPerStukMm3_raw = A_vak * h_avg;
const boorgatPerStukMm3 = getBoorgatVolumePerStukMm3(h_avg);
const volNeutPerStukMm3 = Math.max(0, volNeutPerStukMm3_raw - boorgatPerStukMm3);
const kg_neut = ((volNeutPerStukMm3 * aantal) / 1e6) * FACTOR;
// 3) LOODSPONNING (MIN)
const A_lood = getLoodsponningAreaMm2();
const kg_lood = (((A_lood * len * aantal) / 1e6) * FACTOR);
// 4) KALKSPONNING (MIN) only if vakken selected
let kg_kalk = 0;
if (hasVakkenSelection()) {
const A_kalk = getKalkspAreaMm2();
const h_kalk = getKalkspHeightMm();
if (A_kalk > 0 && h_kalk > 0) {
kg_kalk = (((A_kalk * h_kalk * aantal) / 1e6) * FACTOR);
}
}
const totalKg = (kg_dorpel + kg_neut) - kg_lood - kg_kalk;
return isFinite(totalKg) ? Math.max(0, totalKg) : 0;
}
// ---------------- OUTPUT ----------------
function formatNumberNL(n) {
return (isFinite(n) ? n : 0).toFixed(3).replace('.', ',');
}
// ---------------- HIDDEN FIELD ----------------
function ensureHidden(form) {
let hidden = form.querySelector('input[name="recyclaat_kg"]');
if (!hidden) {
hidden = document.createElement('input');
hidden.type = 'hidden';
hidden.name = 'recyclaat_kg';
form.appendChild(hidden);
}
return hidden;
}
function getForm() {
// Elementor form dichtbij merk veld
const merkInput = document.getElementById('form-field-merk');
return merkInput?.closest('form') || document.querySelector('form.elementor-form') || document.querySelector('form');
}
// ---------------- MAIN UPDATE ----------------
let updateTimer = null;
async function updateAll(forceFetchCart = false) {
const h3 = document.querySelector('.elementor-image-box-title');
const form = getForm();
// 1) local kg (voor hidden + optelling)
const localKg = calcKgLocal();
// 2) server cart kg (altijd meetellen in display)
// fetch niet bij elke keystroke: alleen als oud of force
const tooOld = (Date.now() - lastCartFetchTs) > 1500;
if (forceFetchCart || tooOld) {
await fetchCartKgFromServer();
}
const cartKg = lastCartKg;
// 3) display = cart + local
const displayKg = (isFinite(cartKg) ? cartKg : 0) + (isFinite(localKg) ? localKg : 0);
if (h3) h3.innerText = `${formatNumberNL(displayKg)} kg`;
// 4) hidden = local only (wat naar Woo moet bij add-to-cart)
if (form) {
const hidden = ensureHidden(form);
hidden.value = (isFinite(localKg) ? localKg : 0).toFixed(3);
}
}
function requestUpdate(forceFetchCart = false) {
if (updateTimer) clearTimeout(updateTimer);
updateTimer = setTimeout(() => updateAll(forceFetchCart), 50);
}
// ---------------- EVENTS ----------------
function bindFormSubmit() {
const form = getForm();
if (!form) return;
ensureHidden(form);
form.addEventListener('submit', async () => {
// vlak voor submit: forceer update + forceer cart fetch niet nodig
// (cart fetch is nog pre-add, maar hidden moet goed zijn)
await updateAll(false);
}, true);
// Elementor ajax submit flows
form.addEventListener('formdata', async () => {
await updateAll(false);
});
}
function setupListeners() {
// inputs
['form-field-aantal_get', 'form-field-aantal_gesp', 'display-BIBUlengte', 'form-field-dorpeldikte', 'form-field-merk']
.forEach(id => {
const el = document.getElementById(id);
if (el) {
el.addEventListener('input', () => requestUpdate(false));
el.addEventListener('change', () => requestUpdate(false));
}
});
// radios
$all('input[name="form_fields[vakken]"]').forEach(r => {
r.addEventListener('change', () => requestUpdate(false));
r.addEventListener('input', () => requestUpdate(false));
});
$all('input[name="form_fields[Kleur]"]').forEach(r => {
r.addEventListener('change', () => requestUpdate(false));
r.addEventListener('input', () => requestUpdate(false));
});
$all('input[name="form_fields[dorpeltype]"]').forEach(r => {
r.addEventListener('change', () => setTimeout(() => requestUpdate(false), 0));
r.addEventListener('input', () => setTimeout(() => requestUpdate(false), 0));
});
// Woo events: zodra cart echt bijgewerkt is -> force fetch cart en update display
['added_to_cart', 'wc_fragment_refresh', 'wc_fragments_refreshed', 'removed_from_cart', 'updated_checkout']
.forEach(ev => document.addEventListener(ev, () => requestUpdate(true)));
// periodic safety
setInterval(() => requestUpdate(false), 2000);
}
document.addEventListener('DOMContentLoaded', async () => {
bindFormSubmit();
setupListeners();
// eerste keer: cart ophalen + display
await fetchCartKgFromServer();
await updateAll(false);
});
})();
//// MAATLIJNEN BIJ HS SCHUIFNEUT ////
(function () {
const SVG_ID = "alle-vakken";
const OBSERVE_TIMEOUT_MS = 15000;
// Triggers
const PREFIX_BASIS = "schuifbasis";
const PREFIX_NOK = "schuifnok";
const PREFIX_NEUT = "neut";
// Radio gating
const RADIO_NAME = 'form_fields[verdiept_s]';
const RADIO_ON_VALUE = 'nee';
// Form field voor dorpelbreedte
const DORPEL_SELECTOR =
'#form-field-dorpelbreedte, input[name="form_fields[dorpelbreedte]"], select[name="form_fields[dorpelbreedte]"], textarea[name="form_fields[dorpelbreedte]"]';
// Positionering in SVG-units
const OFFSET_X = 15;
const OFFSET_Y = 0;
// Styling
const STROKE = "rgba(255,255,255,0.75)";
const TEXT_FILL = "rgba(255,255,255,0.85)";
const STROKE_W = 0.6;
const TICK_LEN = 4.5;
const TEXT_GAP = 5;
const FONT_SIZE = 8;
let enabled = false;
let currentContainerG = null;
function getVerdieptIsNee() {
const checked = document.querySelector(
`input[name="${CSS.escape(RADIO_NAME)}"]:checked`
);
return !!checked && String(checked.value).toLowerCase() === RADIO_ON_VALUE;
}
function refreshEnabled() {
enabled = getVerdieptIsNee();
if (!enabled) hideOverlay();
}
function roundToHalf(v) {
return Math.round(v * 2) / 2;
}
function formatVal(v) {
if (v === null || v === undefined || Number.isNaN(v)) return "n/a";
const r = roundToHalf(v);
return (Math.abs(r - Math.round(r)) < 1e-9) ? String(Math.round(r)) : String(r);
}
function readDorpelbreedte() {
const el = document.querySelector(DORPEL_SELECTOR);
if (!el) return NaN;
const raw = (el.value ?? "").toString().trim();
if (!raw) return NaN;
const n = parseFloat(raw.replace(",", "."));
return Number.isFinite(n) ? n : NaN;
}
// ---- Parent detectie ----
function groupHasBasisOrNok(g) {
if (!g || g.nodeType !== 1) return false;
if ((g.tagName || "").toLowerCase() !== "g") return false;
return !!g.querySelector(`[id^="${PREFIX_BASIS}"], [id^="${PREFIX_NOK}"]`);
}
function findContainerGroupFromPoint(evt) {
const els = document.elementsFromPoint(evt.clientX, evt.clientY);
for (const node of els) {
let n = node;
while (n && n !== document && n.nodeType === 1) {
if ((n.tagName || "").toLowerCase() === "g" && groupHasBasisOrNok(n)) {
return n;
}
n = n.parentNode;
}
}
return null;
}
function getBasisElementFromGroup(g) {
if (!g) return null;
return g.querySelector(`[id^="${PREFIX_BASIS}"]`);
}
function getNeutElementFromGroup(g) {
if (!g) return null;
return g.querySelector(`[id^="${PREFIX_NEUT}"]`);
}
function getFirstPolygonOrPolyline(el) {
if (!el) return null;
const tag = (el.tagName || "").toLowerCase();
if (tag === "polygon" || tag === "polyline") return el;
return el.querySelector ? el.querySelector("polygon, polyline") : null;
}
function uniqueSortedLocalYs(poly) {
const EPS = 1e-6;
const ys = [];
for (let i = 0; i < poly.points.numberOfItems; i++) {
const y = poly.points.getItem(i).y;
if (!ys.some(v => Math.abs(v - y) < EPS)) ys.push(y);
}
ys.sort((a, b) => a - b);
return ys;
}
function maxLocalY(poly) {
if (!poly || !poly.points) return NaN;
let m = -Infinity;
for (let i = 0; i < poly.points.numberOfItems; i++) {
const y = poly.points.getItem(i).y;
if (y > m) m = y;
}
return Number.isFinite(m) ? m : NaN;
}
function minLocalX(poly) {
if (!poly || !poly.points) return NaN;
let m = Infinity;
for (let i = 0; i < poly.points.numberOfItems; i++) {
const x = poly.points.getItem(i).x;
if (x < m) m = x;
}
return Number.isFinite(m) ? m : NaN;
}
// ---- Overlay handling ----
let overlayG = null;
let overlayParent = null;
function ensureOverlayFor(poly) {
const parent = poly.parentNode;
if (!parent) return null;
if (overlayG && overlayParent !== parent) {
overlayG.remove();
overlayG = null;
overlayParent = null;
}
if (!overlayG) {
overlayG = document.createElementNS("http://www.w3.org/2000/svg", "g");
overlayG.setAttribute("id", "maatvoering-overlay");
overlayG.setAttribute("pointer-events", "none");
parent.appendChild(overlayG);
overlayParent = parent;
} else {
parent.appendChild(overlayG);
}
return overlayG;
}
function clearOverlay() {
if (!overlayG) return;
while (overlayG.firstChild) overlayG.removeChild(overlayG.firstChild);
}
function hideOverlay() {
if (!overlayG) return;
overlayG.setAttribute("display", "none");
clearOverlay();
}
function showOverlay() {
if (!overlayG) return;
overlayG.setAttribute("display", "inline");
}
function mkLine(x1, y1, x2, y2) {
const l = document.createElementNS("http://www.w3.org/2000/svg", "line");
l.setAttribute("x1", x1);
l.setAttribute("y1", y1);
l.setAttribute("x2", x2);
l.setAttribute("y2", y2);
l.setAttribute("stroke", STROKE);
l.setAttribute("stroke-width", STROKE_W);
l.setAttribute("vector-effect", "non-scaling-stroke");
return l;
}
function mkText(x, y, txt) {
const t = document.createElementNS("http://www.w3.org/2000/svg", "text");
t.setAttribute("x", x);
t.setAttribute("y", y);
t.setAttribute("fill", TEXT_FILL);
t.setAttribute("font-size", FONT_SIZE);
t.setAttribute("dominant-baseline", "middle");
t.setAttribute("text-anchor", "middle");
t.setAttribute("transform", `rotate(-90 ${x} ${y})`);
t.textContent = txt;
return t;
}
function drawMaatlijnForPoly(poly, containerG) {
const g = ensureOverlayFor(poly);
if (!g) return;
clearOverlay();
showOverlay();
const ys = uniqueSortedLocalYs(poly);
if (ys.length < 3) return;
const y0 = ys[0];
const y1 = ys[1];
const y2 = ys[2];
const d1 = (y1 - y0);
const d2 = (y2 - y1);
const dorpel = readDorpelbreedte();
const d3 = Number.isFinite(dorpel) ? (dorpel - d1 - d2) : NaN;
let yEnd = y2;
const neutEl = getNeutElementFromGroup(containerG);
const neutPoly = getFirstPolygonOrPolyline(neutEl);
const neutMaxY = maxLocalY(neutPoly);
if (Number.isFinite(neutMaxY)) yEnd = neutMaxY;
// Firefox-veilige x-bepaling: geen getBBox(), maar polygon-punten
const polyMinX = minLocalX(poly);
if (!Number.isFinite(polyMinX)) return;
const xLine = polyMinX + OFFSET_X;
const xText = xLine - (TICK_LEN + TEXT_GAP);
const Y0 = y0 + OFFSET_Y;
const Y1 = y1 + OFFSET_Y;
const Y2 = y2 + OFFSET_Y;
const YEND = yEnd + OFFSET_Y;
g.appendChild(mkLine(xLine, Y0, xLine, YEND));
g.appendChild(mkLine(xLine - TICK_LEN, Y0, xLine + TICK_LEN, Y0));
g.appendChild(mkLine(xLine - TICK_LEN, Y1, xLine + TICK_LEN, Y1));
g.appendChild(mkLine(xLine - TICK_LEN, Y2, xLine + TICK_LEN, Y2));
g.appendChild(mkLine(xLine - TICK_LEN, YEND, xLine + TICK_LEN, YEND));
const mid1 = (Y0 + Y1) / 2;
const mid2 = (Y1 + Y2) / 2;
const mid3 = (Y2 + YEND) / 2;
g.appendChild(mkText(xText, mid1, formatVal(d1)));
g.appendChild(mkText(xText, mid2, formatVal(d2)));
g.appendChild(mkText(xText, mid3, formatVal(d3)));
}
function redrawIfPossible() {
if (!enabled || !currentContainerG) return;
const basisEl = getBasisElementFromGroup(currentContainerG);
const poly = getFirstPolygonOrPolyline(basisEl);
if (basisEl && poly) drawMaatlijnForPoly(poly, currentContainerG);
}
function setup(svg) {
refreshEnabled();
document.addEventListener("change", (e) => {
const t = e.target;
if (t && t.matches && t.matches(`input[name="${CSS.escape(RADIO_NAME)}"]`)) {
refreshEnabled();
redrawIfPossible();
return;
}
if (t && t.matches && t.matches(DORPEL_SELECTOR)) {
redrawIfPossible();
}
});
document.addEventListener("input", (e) => {
const t = e.target;
if (t && t.matches && t.matches(DORPEL_SELECTOR)) {
redrawIfPossible();
}
});
svg.addEventListener("mousemove", (e) => {
if (!enabled) return;
const containerG = findContainerGroupFromPoint(e);
if (!containerG) {
if (currentContainerG) {
currentContainerG = null;
hideOverlay();
}
return;
}
if (containerG !== currentContainerG) {
currentContainerG = containerG;
const basisEl = getBasisElementFromGroup(containerG);
const poly = getFirstPolygonOrPolyline(basisEl);
if (!basisEl || !poly) {
hideOverlay();
return;
}
drawMaatlijnForPoly(poly, containerG);
}
});
svg.addEventListener("mouseleave", () => {
currentContainerG = null;
hideOverlay();
});
}
function init() {
const svg = document.getElementById(SVG_ID);
if (!svg) return false;
const radioAny = document.querySelector(`input[name="${CSS.escape(RADIO_NAME)}"]`);
if (!radioAny) return false;
setup(svg);
return true;
}
if (init()) return;
const obs = new MutationObserver(() => {
if (init()) obs.disconnect();
});
obs.observe(document.documentElement, { childList: true, subtree: true });
setTimeout(() => obs.disconnect(), OBSERVE_TIMEOUT_MS);
})();
//// MAATLIJNEN BIJ HS SCHUIFNOK VERDIEPT ////
(function () {
const SVG_ID = "alle-vakken";
const OBSERVE_TIMEOUT_MS = 15000;
// Triggers
const PREFIX_BASIS = "schuifbasis";
const PREFIX_NOK = "schuifnok";
// Radio gating
const RADIO_NAME = 'form_fields[verdiept_s]';
const RADIO_ON_VALUE = 'ja';
// Positionering in SVG-units
const OFFSET_X = 15;
const OFFSET_Y = 0;
// Styling
const STROKE = "rgba(255,255,255,0.75)";
const TEXT_FILL = "rgba(255,255,255,0.85)";
const STROKE_W = 0.6;
const TICK_LEN = 4.5;
const TEXT_GAP = 5;
const FONT_SIZE = 8;
let enabled = false;
let currentContainerG = null;
function getVerdieptIsJa() {
const checked = document.querySelector(`input[name="${CSS.escape(RADIO_NAME)}"]:checked`);
return !!checked && String(checked.value).toLowerCase() === RADIO_ON_VALUE;
}
function refreshEnabled() {
enabled = getVerdieptIsJa();
if (!enabled) hideOverlay();
}
function roundToHalf(v) {
return Math.round(v * 2) / 2;
}
function formatVal(v) {
if (v === null || Number.isNaN(v)) return "n/a";
const r = roundToHalf(v);
return (Math.abs(r - Math.round(r)) < 1e-9) ? String(Math.round(r)) : String(r);
}
// ---- Parent detectie ----
function groupHasBasisOrNok(g) {
if (!g || g.nodeType !== 1) return false;
if ((g.tagName || "").toLowerCase() !== "g") return false;
return !!g.querySelector(`[id^="${PREFIX_BASIS}"], [id^="${PREFIX_NOK}"]`);
}
function findContainerGroupFromPoint(evt) {
const els = document.elementsFromPoint(evt.clientX, evt.clientY);
for (const node of els) {
let n = node;
while (n && n !== document && n.nodeType === 1) {
if ((n.tagName || "").toLowerCase() === "g" && groupHasBasisOrNok(n)) {
return n;
}
n = n.parentNode;
}
}
return null;
}
function getBasisElementFromGroup(g) {
if (!g) return null;
return g.querySelector(`[id^="${PREFIX_BASIS}"]`);
}
function getFirstPolygonOrPolyline(el) {
if (!el) return null;
const tag = (el.tagName || "").toLowerCase();
if (tag === "polygon" || tag === "polyline") return el;
return el.querySelector ? el.querySelector("polygon, polyline") : null;
}
function uniqueSortedLocalYs(poly) {
const EPS = 1e-6;
const ys = [];
for (let i = 0; i < poly.points.numberOfItems; i++) {
const y = poly.points.getItem(i).y;
if (!ys.some(v => Math.abs(v - y) < EPS)) ys.push(y);
}
ys.sort((a, b) => a - b);
return ys;
}
function minLocalX(poly) {
if (!poly || !poly.points) return NaN;
let m = Infinity;
for (let i = 0; i < poly.points.numberOfItems; i++) {
const x = poly.points.getItem(i).x;
if (x < m) m = x;
}
return Number.isFinite(m) ? m : NaN;
}
// ---- Overlay handling ----
let overlayG = null;
let overlayParent = null;
function ensureOverlayFor(poly) {
const parent = poly.parentNode;
if (!parent) return null;
if (overlayG && overlayParent !== parent) {
overlayG.remove();
overlayG = null;
overlayParent = null;
}
if (!overlayG) {
overlayG = document.createElementNS("http://www.w3.org/2000/svg", "g");
overlayG.setAttribute("id", "maatvoering-overlay");
overlayG.setAttribute("pointer-events", "none");
parent.appendChild(overlayG);
overlayParent = parent;
} else {
parent.appendChild(overlayG);
}
return overlayG;
}
function clearOverlay() {
if (!overlayG) return;
while (overlayG.firstChild) overlayG.removeChild(overlayG.firstChild);
}
function hideOverlay() {
if (!overlayG) return;
overlayG.setAttribute("display", "none");
clearOverlay();
}
function showOverlay() {
if (!overlayG) return;
overlayG.setAttribute("display", "inline");
}
function mkLine(x1, y1, x2, y2) {
const l = document.createElementNS("http://www.w3.org/2000/svg", "line");
l.setAttribute("x1", x1);
l.setAttribute("y1", y1);
l.setAttribute("x2", x2);
l.setAttribute("y2", y2);
l.setAttribute("stroke", STROKE);
l.setAttribute("stroke-width", STROKE_W);
l.setAttribute("vector-effect", "non-scaling-stroke");
return l;
}
function mkText(x, y, txt) {
const t = document.createElementNS("http://www.w3.org/2000/svg", "text");
t.setAttribute("x", x);
t.setAttribute("y", y);
t.setAttribute("fill", TEXT_FILL);
t.setAttribute("font-size", FONT_SIZE);
t.setAttribute("dominant-baseline", "middle");
t.setAttribute("text-anchor", "middle");
t.setAttribute("transform", `rotate(-90 ${x} ${y})`);
t.textContent = txt;
return t;
}
function drawMaatlijnForPoly(poly) {
const g = ensureOverlayFor(poly);
if (!g) return;
clearOverlay();
showOverlay();
const ys = uniqueSortedLocalYs(poly);
if (ys.length < 4) return;
const y0 = ys[0];
const y1 = ys[1];
const y2 = ys[2];
const y3 = ys[3];
const d1 = (y1 - y0);
const d2 = (y2 - y1);
const d3 = (y3 - y2) - 1;
const polyMinX = minLocalX(poly);
if (!Number.isFinite(polyMinX)) return;
const xLine = polyMinX + OFFSET_X;
const xText = xLine - (TICK_LEN + TEXT_GAP);
const Y0 = y0 + OFFSET_Y;
const Y1 = y1 + OFFSET_Y;
const Y2 = y2 + OFFSET_Y;
const Y3 = y3 + OFFSET_Y;
g.appendChild(mkLine(xLine, Y0, xLine, Y3));
g.appendChild(mkLine(xLine - TICK_LEN, Y0, xLine + TICK_LEN, Y0));
g.appendChild(mkLine(xLine - TICK_LEN, Y1, xLine + TICK_LEN, Y1));
g.appendChild(mkLine(xLine - TICK_LEN, Y2, xLine + TICK_LEN, Y2));
g.appendChild(mkLine(xLine - TICK_LEN, Y3, xLine + TICK_LEN, Y3));
const mid1 = (Y0 + Y1) / 2;
const mid2 = (Y1 + Y2) / 2;
const mid3 = (Y2 + Y3) / 2;
g.appendChild(mkText(xText, mid1, formatVal(d1)));
g.appendChild(mkText(xText, mid2, formatVal(d2)));
g.appendChild(mkText(xText, mid3, formatVal(d3)));
}
function setup(svg) {
refreshEnabled();
document.addEventListener("change", (e) => {
const t = e.target;
if (t && t.matches && t.matches(`input[name="${CSS.escape(RADIO_NAME)}"]`)) {
refreshEnabled();
}
});
svg.addEventListener("mousemove", (e) => {
if (!enabled) return;
const containerG = findContainerGroupFromPoint(e);
if (!containerG) {
if (currentContainerG) {
currentContainerG = null;
hideOverlay();
}
return;
}
if (containerG !== currentContainerG) {
currentContainerG = containerG;
const basisEl = getBasisElementFromGroup(containerG);
const poly = getFirstPolygonOrPolyline(basisEl);
if (!basisEl || !poly) {
hideOverlay();
return;
}
drawMaatlijnForPoly(poly);
}
});
svg.addEventListener("mouseleave", () => {
currentContainerG = null;
hideOverlay();
});
}
function init() {
const svg = document.getElementById(SVG_ID);
if (!svg) return false;
const radioAny = document.querySelector(`input[name="${CSS.escape(RADIO_NAME)}"]`);
if (!radioAny) return false;
setup(svg);
return true;
}
if (init()) return;
const obs = new MutationObserver(() => {
if (init()) obs.disconnect();
});
obs.observe(document.documentElement, { childList: true, subtree: true });
setTimeout(() => obs.disconnect(), OBSERVE_TIMEOUT_MS);
})();
//// MAATLIJNEN BIJ HS VASTNEUT ////
(function () {
const SVG_ID = "alle-vakken";
const OBSERVE_TIMEOUT_MS = 15000;
// Triggers
const PREFIX_BASIS = "vastbasis";
const PREFIX_NOK = "vastnok";
const PREFIX_NEUT = "neut";
// Radio gating
const RADIO_NAME = 'form_fields[verdiept_v]';
const RADIO_ON_VALUE = 'nee';
// Positionering in SVG-units
const OFFSET_X = 15;
const OFFSET_Y = 0;
// Styling
const STROKE = "rgba(255,255,255,0.75)";
const TEXT_FILL = "rgba(255,255,255,0.85)";
const STROKE_W = 0.6;
const TICK_LEN = 4.5;
const TEXT_GAP = 5;
const FONT_SIZE = 8;
// indices
const MEASURE_INDEX_VALUES = [3, 5, 11, 13];
let enabled = false;
let currentContainerG = null;
function getVerdieptIsNee() {
const checked = document.querySelector(`input[name="${CSS.escape(RADIO_NAME)}"]:checked`);
return !!checked && String(checked.value).toLowerCase() === RADIO_ON_VALUE;
}
function refreshEnabled() {
enabled = getVerdieptIsNee();
if (!enabled) hideOverlay();
}
function roundToHalf(v) {
return Math.round(v * 2) / 2;
}
function formatVal(v) {
if (v === null || Number.isNaN(v)) return "n/a";
const r = roundToHalf(v);
return (Math.abs(r - Math.round(r)) < 1e-9) ? String(Math.round(r)) : String(r);
}
// --- container trigger ---
function groupHasBasisOrNok(g) {
if (!g || g.nodeType !== 1) return false;
if ((g.tagName || "").toLowerCase() !== "g") return false;
return !!g.querySelector(`[id^="${PREFIX_BASIS}"], [id^="${PREFIX_NOK}"]`);
}
function findContainerGroupFromPoint(evt) {
const els = document.elementsFromPoint(evt.clientX, evt.clientY);
for (const node of els) {
let n = node;
while (n && n !== document && n.nodeType === 1) {
const tag = (n.tagName || "").toLowerCase();
if (tag === "g" && groupHasBasisOrNok(n)) return n;
n = n.parentNode;
}
}
return null;
}
function getBasisElementFromGroup(g) {
if (!g) return null;
return g.querySelector(`[id^="${PREFIX_BASIS}"]`);
}
function getNeutElementFromGroup(g) {
if (!g) return null;
return g.querySelector(`[id^="${PREFIX_NEUT}"]`);
}
function getFirstPolygonOrPolyline(el) {
if (!el) return null;
const tag = (el.tagName || "").toLowerCase();
if (tag === "polygon" || tag === "polyline") return el;
return el.querySelector ? el.querySelector("polygon, polyline") : null;
}
function uniqueSortedLocalYs(poly) {
const EPS = 1e-6;
const ys = [];
for (let i = 0; i < poly.points.numberOfItems; i++) {
const y = poly.points.getItem(i).y;
if (!ys.some(v => Math.abs(v - y) < EPS)) ys.push(y);
}
ys.sort((a, b) => a - b);
return ys;
}
function getYsFromDataIndexValues(poly, wantedValues) {
if (!poly || !poly.points) return null;
const raw =
poly.getAttribute("data-point-indices-extra") ||
poly.getAttribute("data-point-indices") ||
"";
if (!raw.trim()) return null;
const mapList = raw
.split(",")
.map(s => parseInt(s.trim(), 10))
.filter(n => Number.isFinite(n));
if (mapList.length === 0) return null;
const ys = [];
for (const val of wantedValues) {
const pos = mapList.indexOf(val);
if (pos < 0) return null;
if (pos >= poly.points.numberOfItems) return null;
ys.push(poly.points.getItem(pos).y);
}
return ys;
}
function minLocalX(poly) {
if (!poly || !poly.points) return NaN;
let m = Infinity;
for (let i = 0; i < poly.points.numberOfItems; i++) {
const x = poly.points.getItem(i).x;
if (x < m) m = x;
}
return Number.isFinite(m) ? m : NaN;
}
// ---- overlay ----
let overlayG = null;
let overlayParent = null;
function ensureOverlayFor(poly) {
const parent = poly.parentNode;
if (!parent) return null;
if (overlayG && overlayParent !== parent) {
overlayG.remove();
overlayG = null;
overlayParent = null;
}
if (!overlayG) {
overlayG = document.createElementNS("http://www.w3.org/2000/svg", "g");
overlayG.setAttribute("id", "maatvoering-overlay");
overlayG.setAttribute("pointer-events", "none");
parent.appendChild(overlayG);
overlayParent = parent;
} else {
parent.appendChild(overlayG);
}
return overlayG;
}
function clearOverlay() {
if (!overlayG) return;
while (overlayG.firstChild) overlayG.removeChild(overlayG.firstChild);
}
function hideOverlay() {
if (!overlayG) return;
overlayG.setAttribute("display", "none");
clearOverlay();
}
function showOverlay() {
if (!overlayG) return;
overlayG.setAttribute("display", "inline");
}
function mkLine(x1, y1, x2, y2) {
const l = document.createElementNS("http://www.w3.org/2000/svg", "line");
l.setAttribute("x1", x1);
l.setAttribute("y1", y1);
l.setAttribute("x2", x2);
l.setAttribute("y2", y2);
l.setAttribute("stroke", STROKE);
l.setAttribute("stroke-width", STROKE_W);
l.setAttribute("vector-effect", "non-scaling-stroke");
return l;
}
function mkText(x, y, txt) {
const t = document.createElementNS("http://www.w3.org/2000/svg", "text");
t.setAttribute("x", x);
t.setAttribute("y", y);
t.setAttribute("fill", TEXT_FILL);
t.setAttribute("font-size", FONT_SIZE);
t.setAttribute("dominant-baseline", "middle");
t.setAttribute("text-anchor", "middle");
t.setAttribute("transform", `rotate(-90 ${x} ${y})`);
t.textContent = txt;
return t;
}
function drawMaatlijnForPoly(basisPoly, containerG) {
const g = ensureOverlayFor(basisPoly);
if (!g) return;
clearOverlay();
let ys = getYsFromDataIndexValues(basisPoly, MEASURE_INDEX_VALUES);
if (!ys) {
const fallback = uniqueSortedLocalYs(basisPoly);
if (!fallback || fallback.length < 4) {
hideOverlay();
return;
}
ys = fallback.slice(0, 4);
}
if (!ys || ys.length < 4) {
hideOverlay();
return;
}
let neutTopY = 0;
const neutEl = getNeutElementFromGroup(containerG);
const neutPoly = getFirstPolygonOrPolyline(neutEl);
if (neutPoly && neutPoly.points && neutPoly.points.numberOfItems > 0) {
let minY = Infinity;
for (let i = 0; i < neutPoly.points.numberOfItems; i++) {
const y = neutPoly.points.getItem(i).y;
if (y < minY) minY = y;
}
if (Number.isFinite(minY)) neutTopY = minY;
}
const polyMinX = minLocalX(basisPoly);
if (!Number.isFinite(polyMinX)) {
hideOverlay();
return;
}
showOverlay();
const y0 = neutTopY;
const y1 = ys[1];
const y2 = ys[2];
const y3 = ys[3];
const d1 = (y1 - y0);
const d2 = (y2 - y1);
const d3 = (y3 - y2);
const xLine = polyMinX + OFFSET_X;
const xText = xLine - (TICK_LEN + TEXT_GAP);
const Y0 = y0 + OFFSET_Y;
const Y1 = y1 + OFFSET_Y;
const Y2 = y2 + OFFSET_Y;
const Y3 = y3 + OFFSET_Y;
g.appendChild(mkLine(xLine, Y0, xLine, Y3));
g.appendChild(mkLine(xLine - TICK_LEN, Y0, xLine + TICK_LEN, Y0));
g.appendChild(mkLine(xLine - TICK_LEN, Y1, xLine + TICK_LEN, Y1));
g.appendChild(mkLine(xLine - TICK_LEN, Y2, xLine + TICK_LEN, Y2));
g.appendChild(mkLine(xLine - TICK_LEN, Y3, xLine + TICK_LEN, Y3));
const mid1 = (Y0 + Y1) / 2;
const mid2 = (Y1 + Y2) / 2;
const mid3 = (Y2 + Y3) / 2;
g.appendChild(mkText(xText, mid1, formatVal(d1)));
g.appendChild(mkText(xText, mid2, formatVal(d2)));
g.appendChild(mkText(xText, mid3, formatVal(d3)));
}
function setup(svg) {
refreshEnabled();
document.addEventListener("change", (e) => {
const t = e.target;
if (t && t.matches && t.matches(`input[name="${CSS.escape(RADIO_NAME)}"]`)) {
refreshEnabled();
}
});
const style = document.createElementNS("http://www.w3.org/2000/svg", "style");
style.textContent = `
[id^="${PREFIX_BASIS}"], [id^="${PREFIX_NOK}"] { pointer-events: bounding-box; }
[id^="${PREFIX_BASIS}"] *, [id^="${PREFIX_NOK}"] * { pointer-events: all; }
`;
svg.appendChild(style);
svg.addEventListener("mousemove", (e) => {
if (!enabled) return;
const containerG = findContainerGroupFromPoint(e);
if (!containerG) {
if (currentContainerG) {
currentContainerG = null;
hideOverlay();
}
return;
}
if (containerG !== currentContainerG) {
currentContainerG = containerG;
const basisEl = getBasisElementFromGroup(containerG);
const basisPoly = getFirstPolygonOrPolyline(basisEl);
if (!basisEl || !basisPoly) {
hideOverlay();
return;
}
drawMaatlijnForPoly(basisPoly, containerG);
}
});
svg.addEventListener("mouseleave", () => {
currentContainerG = null;
hideOverlay();
});
}
function init() {
const svg = document.getElementById(SVG_ID);
if (!svg) return false;
const radioAny = document.querySelector(`input[name="${CSS.escape(RADIO_NAME)}"]`);
if (!radioAny) return false;
setup(svg);
return true;
}
if (init()) return;
const obs = new MutationObserver(() => {
if (init()) obs.disconnect();
});
obs.observe(document.documentElement, { childList: true, subtree: true });
setTimeout(() => obs.disconnect(), OBSERVE_TIMEOUT_MS);
})();
//// MAATLIJNEN BIJ HS VASTNOK VERDIEPT ////
(function () {
const SVG_ID = "alle-vakken";
const OBSERVE_TIMEOUT_MS = 15000;
// Triggers
const PREFIX_BASIS = "vastbasis";
const PREFIX_NOK = "vastnok";
// Radio gating
const RADIO_NAME = 'form_fields[verdiept_v]';
const RADIO_ON_VALUE = 'ja';
// Positionering in SVG-units
const OFFSET_X = 15;
const OFFSET_Y = 0;
// Styling
const STROKE = "rgba(255,255,255,0.75)";
const TEXT_FILL = "rgba(255,255,255,0.85)";
const STROKE_W = 0.6;
const TICK_LEN = 4.5;
const TEXT_GAP = 5;
const FONT_SIZE = 8;
// indices
const MEASURE_INDEX_VALUES = [3, 5, 11, 13];
let enabled = false;
let currentContainerG = null;
function getVerdieptIsJa() {
const checked = document.querySelector(`input[name="${CSS.escape(RADIO_NAME)}"]:checked`);
return !!checked && String(checked.value).toLowerCase() === RADIO_ON_VALUE;
}
function refreshEnabled() {
enabled = getVerdieptIsJa();
if (!enabled) hideOverlay();
}
function roundToHalf(v) {
return Math.round(v * 2) / 2;
}
function formatVal(v) {
if (v === null || Number.isNaN(v)) return "n/a";
const r = roundToHalf(v);
return (Math.abs(r - Math.round(r)) < 1e-9) ? String(Math.round(r)) : String(r);
}
function groupHasBasisOrNok(g) {
if (!g || g.nodeType !== 1) return false;
if ((g.tagName || "").toLowerCase() !== "g") return false;
return !!g.querySelector(`[id^="${PREFIX_BASIS}"], [id^="${PREFIX_NOK}"]`);
}
function findContainerGroupFromPoint(evt) {
const els = document.elementsFromPoint(evt.clientX, evt.clientY);
for (const node of els) {
let n = node;
while (n && n !== document && n.nodeType === 1) {
const tag = (n.tagName || "").toLowerCase();
if (tag === "g" && groupHasBasisOrNok(n)) return n;
n = n.parentNode;
}
}
return null;
}
function getBasisElementFromGroup(g) {
if (!g) return null;
return g.querySelector(`[id^="${PREFIX_BASIS}"]`);
}
function getFirstPolygonOrPolyline(el) {
if (!el) return null;
const tag = (el.tagName || "").toLowerCase();
if (tag === "polygon" || tag === "polyline") return el;
return el.querySelector ? el.querySelector("polygon, polyline") : null;
}
function uniqueSortedLocalYs(poly) {
const EPS = 1e-6;
const ys = [];
for (let i = 0; i < poly.points.numberOfItems; i++) {
const y = poly.points.getItem(i).y;
if (!ys.some(v => Math.abs(v - y) < EPS)) ys.push(y);
}
ys.sort((a, b) => a - b);
return ys;
}
function getYsFromDataIndexValues(poly, wantedValues) {
if (!poly || !poly.points) return null;
const raw =
poly.getAttribute("data-point-indices-extra") ||
poly.getAttribute("data-point-indices") ||
"";
if (!raw.trim()) return null;
const mapList = raw
.split(",")
.map(s => parseInt(s.trim(), 10))
.filter(n => Number.isFinite(n));
if (mapList.length === 0) return null;
const ys = [];
for (const val of wantedValues) {
const pos = mapList.indexOf(val);
if (pos < 0) return null;
if (pos >= poly.points.numberOfItems) return null;
ys.push(poly.points.getItem(pos).y);
}
return ys;
}
function minLocalX(poly) {
if (!poly || !poly.points) return NaN;
let m = Infinity;
for (let i = 0; i < poly.points.numberOfItems; i++) {
const x = poly.points.getItem(i).x;
if (x < m) m = x;
}
return Number.isFinite(m) ? m : NaN;
}
// ---- overlay ----
let overlayG = null;
let overlayParent = null;
function ensureOverlayFor(poly) {
const parent = poly.parentNode;
if (!parent) return null;
if (overlayG && overlayParent !== parent) {
overlayG.remove();
overlayG = null;
overlayParent = null;
}
if (!overlayG) {
overlayG = document.createElementNS("http://www.w3.org/2000/svg", "g");
overlayG.setAttribute("id", "maatvoering-overlay");
overlayG.setAttribute("pointer-events", "none");
parent.appendChild(overlayG);
overlayParent = parent;
} else {
parent.appendChild(overlayG);
}
return overlayG;
}
function clearOverlay() {
if (!overlayG) return;
while (overlayG.firstChild) overlayG.removeChild(overlayG.firstChild);
}
function hideOverlay() {
if (!overlayG) return;
overlayG.setAttribute("display", "none");
clearOverlay();
}
function showOverlay() {
if (!overlayG) return;
overlayG.setAttribute("display", "inline");
}
function mkLine(x1, y1, x2, y2) {
const l = document.createElementNS("http://www.w3.org/2000/svg", "line");
l.setAttribute("x1", x1);
l.setAttribute("y1", y1);
l.setAttribute("x2", x2);
l.setAttribute("y2", y2);
l.setAttribute("stroke", STROKE);
l.setAttribute("stroke-width", STROKE_W);
l.setAttribute("vector-effect", "non-scaling-stroke");
return l;
}
function mkText(x, y, txt) {
const t = document.createElementNS("http://www.w3.org/2000/svg", "text");
t.setAttribute("x", x);
t.setAttribute("y", y);
t.setAttribute("fill", TEXT_FILL);
t.setAttribute("font-size", FONT_SIZE);
t.setAttribute("dominant-baseline", "middle");
t.setAttribute("text-anchor", "middle");
t.setAttribute("transform", `rotate(-90 ${x} ${y})`);
t.textContent = txt;
return t;
}
function drawMaatlijnForPoly(poly) {
const g = ensureOverlayFor(poly);
if (!g) return;
clearOverlay();
let ys = getYsFromDataIndexValues(poly, MEASURE_INDEX_VALUES);
if (!ys) {
const fallback = uniqueSortedLocalYs(poly);
if (!fallback || fallback.length < 4) {
hideOverlay();
return;
}
ys = fallback.slice(0, 4);
}
if (!ys || ys.length < 4) {
hideOverlay();
return;
}
const polyMinX = minLocalX(poly);
if (!Number.isFinite(polyMinX)) {
hideOverlay();
return;
}
showOverlay();
const y0 = ys[0];
const y1 = ys[1];
const y2 = ys[2];
const y3 = ys[3];
const d1 = (y1 - y0) -1 ;
const d2 = (y2 - y1);
const d3 = (y3 - y2);
const xLine = polyMinX + OFFSET_X;
const xText = xLine - (TICK_LEN + TEXT_GAP);
const Y0 = y0 + OFFSET_Y;
const Y1 = y1 + OFFSET_Y;
const Y2 = y2 + OFFSET_Y;
const Y3 = y3 + OFFSET_Y;
g.appendChild(mkLine(xLine, Y0, xLine, Y3));
g.appendChild(mkLine(xLine - TICK_LEN, Y0, xLine + TICK_LEN, Y0));
g.appendChild(mkLine(xLine - TICK_LEN, Y1, xLine + TICK_LEN, Y1));
g.appendChild(mkLine(xLine - TICK_LEN, Y2, xLine + TICK_LEN, Y2));
g.appendChild(mkLine(xLine - TICK_LEN, Y3, xLine + TICK_LEN, Y3));
const mid1 = (Y0 + Y1) / 2;
const mid2 = (Y1 + Y2) / 2;
const mid3 = (Y2 + Y3) / 2;
g.appendChild(mkText(xText, mid1, formatVal(d1)));
g.appendChild(mkText(xText, mid2, formatVal(d2)));
g.appendChild(mkText(xText, mid3, formatVal(d3)));
}
function setup(svg) {
refreshEnabled();
document.addEventListener("change", (e) => {
const t = e.target;
if (t && t.matches && t.matches(`input[name="${CSS.escape(RADIO_NAME)}"]`)) {
refreshEnabled();
}
});
const style = document.createElementNS("http://www.w3.org/2000/svg", "style");
style.textContent = `
[id^="${PREFIX_BASIS}"], [id^="${PREFIX_NOK}"] { pointer-events: bounding-box; }
[id^="${PREFIX_BASIS}"] *, [id^="${PREFIX_NOK}"] * { pointer-events: all; }
`;
svg.appendChild(style);
svg.addEventListener("mousemove", (e) => {
if (!enabled) return;
const containerG = findContainerGroupFromPoint(e);
if (!containerG) {
if (currentContainerG) {
currentContainerG = null;
hideOverlay();
}
return;
}
if (containerG !== currentContainerG) {
currentContainerG = containerG;
const basisEl = getBasisElementFromGroup(containerG);
const poly = getFirstPolygonOrPolyline(basisEl);
if (!basisEl || !poly) {
hideOverlay();
return;
}
drawMaatlijnForPoly(poly);
}
});
svg.addEventListener("mouseleave", () => {
currentContainerG = null;
hideOverlay();
});
}
function init() {
const svg = document.getElementById(SVG_ID);
if (!svg) return false;
const radioAny = document.querySelector(`input[name="${CSS.escape(RADIO_NAME)}"]`);
if (!radioAny) return false;
setup(svg);
return true;
}
if (init()) return;
const obs = new MutationObserver(() => {
if (init()) obs.disconnect();
});
obs.observe(document.documentElement, { childList: true, subtree: true });
setTimeout(() => obs.disconnect(), OBSERVE_TIMEOUT_MS);
})();
//// Y>X boorgatverschuiving #dorpel + collision met juiste schuinte-marge (SAT) ////
//// ✅ Trigger alléén als dorpeltype = KVT of KVTPKU ////
//// ✅ Popup pas tonen nadat "vakken" radio is gekozen ////
document.addEventListener('DOMContentLoaded', function () {
// SVG + elementen
const svg = document.querySelector('svg#dorpel');
if (!svg) return;
const boorgat1 = svg.querySelector('#boorgat-1');
const boorgat2 = svg.querySelector('#boorgat-2');
if (!boorgat1 || !boorgat2) {
console.warn('boorgat-1 of boorgat-2 niet gevonden in SVG');
return;
}
// Hit-elements: liever de rect binnen de boorgat-groep
const boorgat1HitEl = boorgat1.querySelector('rect') || boorgat1;
const boorgat2HitEl = boorgat2.querySelector('rect') || boorgat2;
// Marges voor de ondersteunde dorpeltypes
const margeKVT = svg.querySelector('#KVT_x5F_schuinte_x5F_marge');
const margeKVTPKU = svg.querySelector('#KVTPKU_x5F_schuinte_x5F_marge');
// Popup (bestaat al in je HTML)
const popup = document.querySelector('#message-popup-boorgaten');
if (!popup) {
console.warn('#message-popup-boorgaten niet gevonden in DOM');
return;
}
function togglePopup(show) {
popup.style.display = show ? 'block' : 'none';
}
// Formuliervelden
const field1Y = document.querySelector('#form-field-1Y');
const field2Y = document.querySelector('#form-field-2Y');
const fieldDorpel = document.querySelector('#form-field-dorpelbreedte');
// extra veld dat de geometrie beïnvloedt
const fieldSponningBUVD = document.querySelector('#form-field-sponningdiepte_buvd');
// dorpeltype radio's
const dorpeltypeSelector = 'input[name="form_fields[dorpeltype]"]';
function getSelectedOriginalType() {
const checked = document.querySelector(`${dorpeltypeSelector}:checked`);
if (!checked) return null;
return (checked.dataset.originalValue || checked.value || '').toUpperCase().trim();
}
function isSupportedTypeSelected() {
const type = getSelectedOriginalType();
return type === 'KVT' || type === 'KVTPKU';
}
function getActiveMarge() {
const type = getSelectedOriginalType();
if (type === 'KVT') return margeKVT;
if (type === 'KVTPKU') return margeKVTPKU;
return null;
}
// vakken radio's (moet eerst gekozen zijn)
const vakkenSelector = 'input[name="form_fields[vakken]"]';
function isVakkenSelected() {
return !!document.querySelector(`${vakkenSelector}:checked`);
}
// display="none" opheffen in live DOM
boorgat1.removeAttribute('display');
boorgat2.removeAttribute('display');
boorgat1.style.display = 'inline';
boorgat2.style.display = 'inline';
// Basiswaarden (nulstand)
const base1Y = Number(field1Y?.value || 30);
const base2Y = Number(field2Y?.value || 30);
const baseWidth = Number(fieldDorpel?.value || 114);
const baseTransform1 = boorgat1.getAttribute('transform') || '';
const baseTransform2 = boorgat2.getAttribute('transform') || '';
function makeTransform(baseTransform, deltaX) {
const extra = 'translate(' + deltaX + ',0)';
return baseTransform ? (baseTransform + ' ' + extra) : extra;
}
// ---- SAT helpers ----
function getBoxCorners(el) {
const ctm = el.getCTM();
const b = el.getBBox();
const cornersLocal = [
{ x: b.x, y: b.y },
{ x: b.x + b.width, y: b.y },
{ x: b.x + b.width, y: b.y + b.height },
{ x: b.x, y: b.y + b.height }
];
return cornersLocal.map(p => ({
x: p.x * ctm.a + p.y * ctm.c + ctm.e,
y: p.x * ctm.b + p.y * ctm.d + ctm.f
}));
}
function projectOnAxis(points, axis) {
let min = Infinity, max = -Infinity;
for (const p of points) {
const d = p.x * axis.x + p.y * axis.y;
if (d < min) min = d;
if (d > max) max = d;
}
return { min, max };
}
function rectOverlapSAT(rectA, rectB, clearance = 0) {
const axes = [];
const addAxesFrom = (pts) => {
for (let i = 0; i < 2; i++) {
const p1 = pts[i], p2 = pts[(i + 1) % 4];
const nx = -(p2.y - p1.y), ny = (p2.x - p1.x);
const len = Math.hypot(nx, ny) || 1;
const ax = { x: nx / len, y: ny / len };
const key = ax.x.toFixed(6) + ',' + ax.y.toFixed(6);
if (!axes.some(a => a.k === key)) axes.push({ ...ax, k: key });
}
};
addAxesFrom(rectA);
addAxesFrom(rectB);
for (const axis of axes) {
const a = projectOnAxis(rectA, axis);
const b = projectOnAxis(rectB, axis);
if (a.max < b.min - clearance || b.max < a.min - clearance) return false;
}
return true;
}
// ---- display="none" parent tijdelijk meetbaar maken ----
function withMeasurable(el, fn) {
const touched = [];
let cur = el;
while (cur && cur !== svg) {
if (cur.nodeType === 1) {
const disp = cur.getAttribute('display');
if (disp && disp.toLowerCase() === 'none') {
touched.push({
node: cur,
display: disp,
vis: cur.style.visibility,
op: cur.style.opacity,
pe: cur.style.pointerEvents
});
cur.setAttribute('display', 'inline');
cur.style.visibility = 'hidden';
cur.style.opacity = '0';
cur.style.pointerEvents = 'none';
}
}
cur = cur.parentNode;
}
let out;
try {
out = fn();
} finally {
for (let i = touched.length - 1; i >= 0; i--) {
const t = touched[i];
t.node.setAttribute('display', t.display);
t.node.style.visibility = t.vis;
t.node.style.opacity = t.op;
t.node.style.pointerEvents = t.pe;
}
}
return out;
}
function collidesSAT(elA, elB) {
const B = withMeasurable(elB, () => getBoxCorners(elB));
const A = getBoxCorners(elA);
if (!A.length || !B.length) return false;
return rectOverlapSAT(A, B, 0);
}
function checkCollisionAndToggle() {
// Alleen actief bij KVT of KVTPKU
if (!isSupportedTypeSelected()) {
togglePopup(false);
return;
}
const marge = getActiveMarge();
if (!marge) {
console.warn('Schuinte-marge niet gevonden voor geselecteerd dorpeltype:', getSelectedOriginalType());
togglePopup(false);
return;
}
const hit =
collidesSAT(boorgat1HitEl, marge) ||
collidesSAT(boorgat2HitEl, marge);
// Popup pas tonen als "vakken" is gekozen
togglePopup(hit && isVakkenSelected());
}
// --- #boorgat-1 ---
function updateBoorgat1() {
if (!field1Y) return;
const v = Number(field1Y.value);
const vSafe = Number.isFinite(v) ? v : base1Y;
const deltaX = base1Y - vSafe;
boorgat1.setAttribute('transform', makeTransform(baseTransform1, deltaX));
}
// --- #boorgat-2 ---
function updateBoorgat2() {
if (!field2Y || !fieldDorpel) return;
const v2 = Number(field2Y.value);
const w = Number(fieldDorpel.value);
const v2Safe = Number.isFinite(v2) ? v2 : base2Y;
const wSafe = Number.isFinite(w) ? w : baseWidth;
const deltaWidth = baseWidth - wSafe;
const delta2Y = v2Safe - base2Y;
const deltaX = deltaWidth + delta2Y;
boorgat2.setAttribute('transform', makeTransform(baseTransform2, deltaX));
}
function recompute() {
updateBoorgat1();
updateBoorgat2();
checkCollisionAndToggle();
}
// Init
recompute();
// Event listeners (inputs die boorgaten beïnvloeden)
[field1Y, field2Y, fieldDorpel, fieldSponningBUVD].forEach(el => {
if (!el) return;
el.addEventListener('input', recompute);
el.addEventListener('change', recompute);
});
// Dorpeltype wijziging moet ook collision re-checken
document.addEventListener('change', (e) => {
if (e.target && e.target.matches(dorpeltypeSelector)) {
recompute();
}
});
// Vakken selectie: zodra gekozen -> check opnieuw
document.addEventListener('change', (e) => {
if (e.target && e.target.matches(vakkenSelector)) {
checkCollisionAndToggle();
}
});
window.addEventListener('resize', checkCollisionAndToggle);
});
<.script>
//// y schuinte aanpassing bi/kvtpki + shiftbox INIT ////
(function() {
const num = v => parseFloat(v || 0);
const r3 = v => Math.round(v * 1000) / 1000;
const r6 = v => Math.round(v * 1e6) / 1e6;
const EPS = 1e-6;
// ---- helpers voor transforms / hit-test ----
function getSVG(el) {
return el && (el.ownerSVGElement || (el.tagName && el.tagName.toLowerCase() === 'svg' ? el : el.closest('svg')));
}
function rectToGlobal(svg, rect) {
const x = num(rect.getAttribute('x'));
const y = num(rect.getAttribute('y'));
const w = num(rect.getAttribute('width'));
const h = num(rect.getAttribute('height'));
const pt = svg.createSVGPoint();
const m = rect.getCTM && rect.getCTM();
const tx = (px, py) => {
pt.x = px;
pt.y = py;
const q = m ? pt.matrixTransform(m) : pt;
return { x: q.x, y: q.y };
};
const p1 = tx(x, y);
const p2 = tx(x + w, y);
const p3 = tx(x, y + h);
const p4 = tx(x + w, y + h);
return {
minX: Math.min(p1.x, p2.x, p3.x, p4.x),
maxX: Math.max(p1.x, p2.x, p3.x, p4.x),
minY: Math.min(p1.y, p2.y, p3.y, p4.y),
maxY: Math.max(p1.y, p2.y, p3.y, p4.y)
};
}
function pointToGlobal(svg, el, x, y) {
const pt = svg.createSVGPoint();
pt.x = x;
pt.y = y;
const m = el.getCTM && el.getCTM();
const q = m ? pt.matrixTransform(m) : pt;
return { x: q.x, y: q.y };
}
function insideBox(svg, pathEl, x, y, box) {
const p = pointToGlobal(svg, pathEl, x, y);
return (
p.x >= box.minX - EPS && p.x <= box.maxX + EPS &&
p.y >= box.minY - EPS && p.y <= box.maxY + EPS
);
}
// ---- token/path helpers ----
function parseTokens(d) {
return (d || '').match(/[A-Za-z]|-?\d*\.?\d+(?:e[-+]?\d+)?/g);
}
function hasRelativeCommands(d) {
const cmds = (d || '').match(/[A-Za-z]/g);
if (!cmds) return false;
return cmds.some(c => c !== c.toUpperCase());
}
function getCommandSignature(tokens) {
if (!tokens) return '';
return tokens.filter(t => /^[A-Za-z]$/.test(t)).map(t => t.toUpperCase()).join('|');
}
const SPEC = { M:2, L:2, H:1, V:1, C:6, S:4, Q:4, T:2, A:7, Z:0 };
// ---- path parser absolute, H/V behouden ----
function parsePathToAbsoluteSegments(pathEl) {
if (!pathEl) return [];
const d = pathEl.getAttribute('d');
if (!d) return [];
const tok = parseTokens(d);
if (!tok) return [];
let i = 0, curX = 0, curY = 0, lastCmd = '';
let subStartX = 0, subStartY = 0;
const segments = [];
const take = () => tok[i++];
const isCmd = t => /^[A-Za-z]$/.test(t);
const toAbs = (rel, x, y) => rel ? [curX + x, curY + y] : [x, y];
while (i < tok.length) {
let cmd = take();
if (!isCmd(cmd)) { i--; cmd = lastCmd; } else { lastCmd = cmd; }
const ABS = cmd.toUpperCase();
const rel = cmd !== ABS;
if (ABS === 'Z') {
segments.push({ cmd: 'Z' });
curX = subStartX;
curY = subStartY;
continue;
}
const nPer = SPEC[ABS];
if (!nPer) continue;
let buf = [];
while (i < tok.length && !isCmd(tok[i])) {
buf.push(parseFloat(take()));
if (buf.length % nPer === 0) {
const n = buf.splice(buf.length - nPer, nPer);
switch (ABS) {
case 'M': {
const [x, y] = toAbs(rel, n[0], n[1]);
segments.push({ cmd: 'M', x, y });
curX = x; curY = y; subStartX = x; subStartY = y;
break;
}
case 'L': {
const [x, y] = toAbs(rel, n[0], n[1]);
segments.push({ cmd: 'L', x, y });
curX = x; curY = y;
break;
}
case 'H': {
const x = rel ? curX + n[0] : n[0];
segments.push({ cmd: 'H', x });
curX = x;
break;
}
case 'V': {
const y = rel ? curY + n[0] : n[0];
segments.push({ cmd: 'V', y });
curY = y;
break;
}
case 'T': {
const [x, y] = toAbs(rel, n[0], n[1]);
segments.push({ cmd: 'T', x, y });
curX = x; curY = y;
break;
}
case 'C': {
const [x1, y1] = toAbs(rel, n[0], n[1]);
const [x2, y2] = toAbs(rel, n[2], n[3]);
const [x, y] = toAbs(rel, n[4], n[5]);
segments.push({ cmd: 'C', x1, y1, x2, y2, x, y });
curX = x; curY = y;
break;
}
case 'S': {
const [x2, y2] = toAbs(rel, n[0], n[1]);
const [x, y] = toAbs(rel, n[2], n[3]);
segments.push({ cmd: 'S', x2, y2, x, y });
curX = x; curY = y;
break;
}
case 'Q': {
const [x1, y1] = toAbs(rel, n[0], n[1]);
const [x, y] = toAbs(rel, n[2], n[3]);
segments.push({ cmd: 'Q', x1, y1, x, y });
curX = x; curY = y;
break;
}
case 'A': {
const rx = n[0], ry = n[1], rot = n[2], laf = n[3], sf = n[4];
const [x, y] = toAbs(rel, n[5], n[6]);
segments.push({ cmd: 'A', rx, ry, rot, laf, sf, x, y });
curX = x; curY = y;
break;
}
}
}
}
}
return segments;
}
function writeAbsoluteSegmentsToPath(pathEl, segments) {
if (!pathEl || !Array.isArray(segments)) return;
const out = [];
segments.forEach(seg => {
switch (seg.cmd) {
case 'M':
out.push('M', r6(seg.x), r6(seg.y));
break;
case 'L':
out.push('L', r6(seg.x), r6(seg.y));
break;
case 'H':
out.push('H', r6(seg.x));
break;
case 'V':
out.push('V', r6(seg.y));
break;
case 'T':
out.push('T', r6(seg.x), r6(seg.y));
break;
case 'C':
out.push('C', r6(seg.x1), r6(seg.y1), r6(seg.x2), r6(seg.y2), r6(seg.x), r6(seg.y));
break;
case 'S':
out.push('S', r6(seg.x2), r6(seg.y2), r6(seg.x), r6(seg.y));
break;
case 'Q':
out.push('Q', r6(seg.x1), r6(seg.y1), r6(seg.x), r6(seg.y));
break;
case 'A':
out.push('A', seg.rx, seg.ry, seg.rot, seg.laf, seg.sf, r6(seg.x), r6(seg.y));
break;
case 'Z':
out.push('Z');
break;
}
});
pathEl.setAttribute('d', out.join(' ').replace(/\s+/g, ' ').trim());
}
function buildFrozenPathMeta(pathEl) {
if (!pathEl) return null;
const d = pathEl.getAttribute('d');
if (!d) return null;
const tok = parseTokens(d);
if (!tok) return null;
const segments = parsePathToAbsoluteSegments(pathEl);
let i = 0, lastCmd = '';
const tokenMap = [];
const take = () => tok[i++];
const isCmd = t => /^[A-Za-z]$/.test(t);
while (i < tok.length) {
let cmd = take();
if (!isCmd(cmd)) { i--; cmd = lastCmd; } else { lastCmd = cmd; }
const ABS = cmd.toUpperCase();
if (ABS === 'Z') {
tokenMap.push({ cmd: 'Z' });
continue;
}
const nPer = SPEC[ABS];
if (!nPer) continue;
let idxBuf = [];
while (i < tok.length && !isCmd(tok[i])) {
idxBuf.push(i);
take();
if (idxBuf.length % nPer === 0) {
const idxs = idxBuf.splice(idxBuf.length - nPer, nPer);
switch (ABS) {
case 'M':
case 'L':
case 'T':
tokenMap.push({ cmd: ABS, x: idxs[0], y: idxs[1] });
break;
case 'H':
tokenMap.push({ cmd: 'H', x: idxs[0] });
break;
case 'V':
tokenMap.push({ cmd: 'V', y: idxs[0] });
break;
case 'C':
tokenMap.push({ cmd:'C', x1:idxs[0], y1:idxs[1], x2:idxs[2], y2:idxs[3], x:idxs[4], y:idxs[5] });
break;
case 'S':
tokenMap.push({ cmd:'S', x2:idxs[0], y2:idxs[1], x:idxs[2], y:idxs[3] });
break;
case 'Q':
tokenMap.push({ cmd:'Q', x1:idxs[0], y1:idxs[1], x:idxs[2], y:idxs[3] });
break;
case 'A':
tokenMap.push({ cmd:'A', rx:idxs[0], ry:idxs[1], rot:idxs[2], laf:idxs[3], sf:idxs[4], x:idxs[5], y:idxs[6] });
break;
}
}
}
}
return {
signature: getCommandSignature(tok),
segments,
tokenMap
};
}
function ensureFrozenPath(pathEl) {
if (!pathEl) return null;
if (pathEl._frozenPathMeta) return pathEl._frozenPathMeta;
const d = pathEl.getAttribute('d');
if (!d) return null;
if (hasRelativeCommands(d)) {
const segments = parsePathToAbsoluteSegments(pathEl);
writeAbsoluteSegmentsToPath(pathEl, segments);
}
pathEl._frozenPathMeta = buildFrozenPathMeta(pathEl);
return pathEl._frozenPathMeta;
}
function clearFrozenMeta(paths) {
paths.forEach(p => {
if (p) delete p._frozenPathMeta;
});
}
function getPrevEndYRef(meta, segIndex) {
for (let i = segIndex - 1; i >= 0; i--) {
const seg = meta.segments[i];
if (!seg) continue;
switch (seg.cmd) {
case 'M':
case 'L':
case 'T':
case 'V':
case 'C':
case 'S':
case 'Q':
case 'A':
return { segIndex: i, field: 'y' };
case 'H':
case 'Z':
break;
}
}
return null;
}
function capturePathYRefs(pathEl, box) {
const meta = ensureFrozenPath(pathEl);
if (!meta || !Array.isArray(meta.segments)) return [];
const refs = [];
const seen = new Set();
function add(segIndex, field) {
const key = segIndex + ':' + field;
if (seen.has(key)) return;
seen.add(key);
refs.push({ segIndex, field });
}
let curX = 0, curY = 0;
let subStartX = 0, subStartY = 0;
meta.segments.forEach((seg, segIndex) => {
switch (seg.cmd) {
case 'M':
if (insideBox(getSVG(pathEl), pathEl, seg.x, seg.y, box)) add(segIndex, 'y');
curX = seg.x; curY = seg.y; subStartX = seg.x; subStartY = seg.y;
break;
case 'L':
case 'T':
if (insideBox(getSVG(pathEl), pathEl, seg.x, seg.y, box)) add(segIndex, 'y');
curX = seg.x; curY = seg.y;
break;
case 'H': {
const endX = seg.x;
const endY = curY;
if (insideBox(getSVG(pathEl), pathEl, endX, endY, box)) {
const prevRef = getPrevEndYRef(meta, segIndex);
if (prevRef) add(prevRef.segIndex, prevRef.field);
}
curX = seg.x;
break;
}
case 'V':
if (insideBox(getSVG(pathEl), pathEl, curX, seg.y, box)) add(segIndex, 'y');
curY = seg.y;
break;
case 'C':
if (insideBox(getSVG(pathEl), pathEl, seg.x1, seg.y1, box)) add(segIndex, 'y1');
if (insideBox(getSVG(pathEl), pathEl, seg.x2, seg.y2, box)) add(segIndex, 'y2');
if (insideBox(getSVG(pathEl), pathEl, seg.x, seg.y, box)) add(segIndex, 'y');
curX = seg.x; curY = seg.y;
break;
case 'S':
if (insideBox(getSVG(pathEl), pathEl, seg.x2, seg.y2, box)) add(segIndex, 'y2');
if (insideBox(getSVG(pathEl), pathEl, seg.x, seg.y, box)) add(segIndex, 'y');
curX = seg.x; curY = seg.y;
break;
case 'Q':
if (insideBox(getSVG(pathEl), pathEl, seg.x1, seg.y1, box)) add(segIndex, 'y1');
if (insideBox(getSVG(pathEl), pathEl, seg.x, seg.y, box)) add(segIndex, 'y');
curX = seg.x; curY = seg.y;
break;
case 'A':
if (insideBox(getSVG(pathEl), pathEl, seg.x, seg.y, box)) add(segIndex, 'y');
curX = seg.x; curY = seg.y;
break;
case 'Z':
curX = subStartX; curY = subStartY;
break;
}
});
return refs;
}
function adjustPathYCaptured(pathEl, refs, delta) {
if (!pathEl || !Array.isArray(refs) || !refs.length || Math.abs(delta) < EPS) return;
const meta = ensureFrozenPath(pathEl);
if (!meta) return;
const d = pathEl.getAttribute('d');
if (!d) return;
const tok = parseTokens(d);
if (!tok) return;
if (getCommandSignature(tok) !== meta.signature) {
console.warn('Padstructuur gewijzigd; bi/kvtpki schuinte script slaat dit pad over:', pathEl.id);
return;
}
refs.forEach(ref => {
const map = meta.tokenMap[ref.segIndex];
if (!map || map[ref.field] == null) return;
const idx = map[ref.field];
const v = parseFloat(tok[idx]);
if (!isFinite(v)) return;
tok[idx] = String(r6(v + delta));
});
pathEl.setAttribute('d', tok.join(' ').replace(/\s+/g, ' ').trim());
}
// ---- shiftbox helpers ----
function moveRectFromWidth(rect, dx) {
const x = num(rect.getAttribute('x'));
const y = num(rect.getAttribute('y'));
rect.setAttribute('x', r3(x - dx));
rect.setAttribute('y', r3(y + dx / 12));
}
function moveRectFromBiv(rect, dBiv) {
const y = num(rect.getAttribute('y'));
rect.setAttribute('y', r3(y - dBiv / 12));
}
function init() {
const inputWidth = document.querySelector('#form-field-dorpelbreedte');
const inputBiv = document.querySelector('#form-field-sponningdiepte_bi');
const rect = document.querySelector('#y-shiftbox-dorpelbreedte-BIV-dorpel rect')
|| document.querySelector('#y-shiftbox-sponning-BIV-dorpel rect');
const paths = [
document.querySelector('#BIV_x5F_neut'),
document.querySelector('#BIV_x5F_dorpel'),
document.querySelector('#KVTPKI_x5F_neut'),
document.querySelector('#KVTPKI_x5F_dorpel')
].filter(Boolean);
if (!inputWidth || !inputBiv || !rect || !paths.length) {
setTimeout(init, 250);
return;
}
let lastW = num(inputWidth.value);
let lastB = num(inputBiv.value);
const getBivMin = () => {
const m = parseFloat(inputBiv.min);
return Number.isFinite(m) ? m : -Infinity;
};
const computeBivMax = widthVal => widthVal;
let captures = [];
function rebuildCaptures() {
clearFrozenMeta(paths);
const box = rectToGlobal(getSVG(rect), rect);
captures = paths.map(pathEl => {
ensureFrozenPath(pathEl);
return {
el: pathEl,
refs: capturePathYRefs(pathEl, box)
};
});
}
function applyCapturedY(dy) {
if (!dy) return;
captures.forEach(item => adjustPathYCaptured(item.el, item.refs, dy));
}
function onWidthChange() {
const cur = num(inputWidth.value);
const dx = cur - lastW;
if (!dx) return;
// eerst punten, dan shiftbox
applyCapturedY(dx / 12);
moveRectFromWidth(rect, dx);
lastW = cur;
const dynMax = computeBivMax(cur);
if (lastB > dynMax) {
const dClamp = dynMax - lastB;
applyCapturedY(-dClamp / 12);
moveRectFromBiv(rect, dClamp);
lastB = dynMax;
inputBiv.value = String(r3(dynMax));
}
}
function onBivChange() {
const cur = num(inputBiv.value);
const minB = getBivMin();
const dynMax = computeBivMax(lastW);
if (cur < minB || cur > dynMax) {
inputBiv.setAttribute('aria-invalid', 'true');
return;
}
inputBiv.removeAttribute('aria-invalid');
const d = cur - lastB;
if (!d) return;
applyCapturedY(-d / 12);
moveRectFromBiv(rect, d);
lastB = cur;
}
function rebuildAfterDorpeltypeChange() {
lastW = num(inputWidth.value);
if (!Number.isFinite(lastW)) lastW = 0;
lastB = num(inputBiv.value);
if (!Number.isFinite(lastB)) lastB = getBivMin();
rebuildCaptures();
}
inputWidth.addEventListener('input', onWidthChange);
inputWidth.addEventListener('change', onWidthChange);
inputBiv.addEventListener('input', onBivChange);
inputBiv.addEventListener('change', onBivChange);
document.addEventListener('change', e => {
const t = e.target;
if (t && t.matches && t.matches('input[name="form_fields[dorpeltype]"]')) {
setTimeout(() => {
requestAnimationFrame(() => requestAnimationFrame(() => {
rebuildAfterDorpeltypeChange();
}));
}, 70);
}
}, { passive: true });
rebuildCaptures();
onWidthChange();
const initMin = getBivMin();
const initMax = computeBivMax(lastW);
const initVal = num(inputBiv.value);
if (initVal >= initMin && initVal <= initMax) onBivChange();
}
if (document.readyState === 'loading') {
document.addEventListener('DOMContentLoaded', init);
} else {
init();
}
})();
//// y schuinte aanpassing buvd/kvt/kvtpku/kvtpbu/hs shiftbox INIT ////
(function () {
// ===== Inputs =====
const $db = document.getElementById('form-field-dorpelbreedte');
const $bu = document.getElementById('form-field-sponningdiepte_buvd');
const $hs = document.getElementById('form-field-sponningdiepte_hs');
if (!$db || !$bu || !$hs) return;
// ===== SVG (scope!) & shiftboxen =====
const svg = document.getElementById('dorpel');
if (!svg || svg.tagName.toLowerCase() !== 'svg') return;
const rBUVD = svg.querySelector('#y-shiftbox-sponning-BUVD-dorpel rect');
const rKVT = svg.querySelector('#y-shiftbox-sponning-KVT-dorpel rect');
const rKVTPKU = svg.querySelector('#y-shiftbox-sponning-KVTPKU-dorpel rect');
const rKVTPBU = svg.querySelector('#y-shiftbox-sponning-KVTPBU-dorpel rect');
const rHS = svg.querySelector('#y-shiftbox-sponning-HS-dorpel rect');
if (!rBUVD || !rKVT || !rHS) return;
// ===== Targets (scoped selectors) =====
const TARGETS = {
BUVD: ['#BUVD_x5F_neut', '#BUVD_x5F_dorpel'],
KVT: ['#KVT_x5F_neut', '#KVT_x5F_dorpel'],
KVTPKU: ['#KVTPKU_x5F_neut', '#KVTPKU_x5F_dorpel'],
KVTPBU: ['#KVTPBU_x5F_neut', '#KVTPBU_x5F_dorpel'],
HS: ['#HS_x5F_neut', '#HS_x5F_dorpel']
};
// ===== State & utils =====
const num = v => (v == null || v === '') ? NaN : parseFloat(v);
const r3 = v => Math.round(v * 1000) / 1000;
const EPS = 1e-6;
function clampValid(v, min, max, clampAbove, blockBelow, fallback) {
if (!Number.isFinite(v)) return fallback;
if (v > max) return clampAbove ? max : v;
if (v < min) return blockBelow ? NaN : min;
return v;
}
function getDynMax() {
const v = num($db.value);
return Number.isFinite(v) ? v : lastDB;
}
let lastDB = num($db.value);
if (!Number.isFinite(lastDB)) lastDB = num($db.getAttribute('value'));
if (!Number.isFinite(lastDB)) lastDB = 0;
const BU_MIN = num($bu.getAttribute('min'));
const HS_MIN = num($hs.getAttribute('min'));
const safeBU_MIN = Number.isFinite(BU_MIN) ? BU_MIN : 0;
const safeHS_MIN = Number.isFinite(HS_MIN) ? HS_MIN : 0;
let lastBU = clampValid(num($bu.value), safeBU_MIN, getDynMax(), true, true, safeBU_MIN);
let lastHS = clampValid(num($hs.value), safeHS_MIN, getDynMax(), true, true, safeHS_MIN);
let pDx = 0, pDy = 0, pBu = 0, pKvt = 0, pKvtPku = 0, pKvtPbu = 0, pHs = 0, pDyHSBox = 0;
let rafId = 0;
// ===== Transform helpers =====
function rectAABBInRoot(rectEl) {
if (!rectEl) return null;
const x = num(rectEl.getAttribute('x')) || 0;
const y = num(rectEl.getAttribute('y')) || 0;
const w = num(rectEl.getAttribute('width')) || 0;
const h = num(rectEl.getAttribute('height')) || 0;
const m = rectEl.getCTM ? rectEl.getCTM() : null;
const pt = svg.createSVGPoint();
function tx(px, py) {
pt.x = px;
pt.y = py;
const r = m ? pt.matrixTransform(m) : pt;
return { x: r.x, y: r.y };
}
const p1 = tx(x, y), p2 = tx(x + w, y), p3 = tx(x, y + h), p4 = tx(x + w, y + h);
return {
minX: Math.min(p1.x, p2.x, p3.x, p4.x),
maxX: Math.max(p1.x, p2.x, p3.x, p4.x),
minY: Math.min(p1.y, p2.y, p3.y, p4.y),
maxY: Math.max(p1.y, p2.y, p3.y, p4.y)
};
}
function pointToRoot(el, x, y) {
const pt = svg.createSVGPoint();
pt.x = x;
pt.y = y;
const m = el.getCTM ? el.getCTM() : null;
const r = m ? pt.matrixTransform(m) : pt;
return { x: r.x, y: r.y };
}
function isInsideRootAABB(pathEl, aabbRoot, x, y) {
if (!aabbRoot) return false;
const p = pointToRoot(pathEl, x, y);
return (
p.x >= aabbRoot.minX - EPS && p.x <= aabbRoot.maxX + EPS &&
p.y >= aabbRoot.minY - EPS && p.y <= aabbRoot.maxY + EPS
);
}
// ===== Path freeze helpers =====
function parseTokens(d) {
return (d || '').match(/[A-Za-z]|-?\d*\.?\d+(?:e[-+]?\d+)?/g);
}
function hasRelativeCommands(d) {
const cmds = (d || '').match(/[A-Za-z]/g);
if (!cmds) return false;
return cmds.some(c => c !== c.toUpperCase());
}
function getCommandSignature(tokens) {
if (!tokens) return '';
return tokens.filter(t => /^[A-Za-z]$/.test(t)).map(t => t.toUpperCase()).join('|');
}
const SPEC = { M:2, L:2, H:1, V:1, C:6, S:4, Q:4, T:2, A:7, Z:0 };
function parsePathToAbsoluteSegments(pathEl) {
if (!pathEl) return [];
const d = pathEl.getAttribute('d');
if (!d) return [];
const tok = parseTokens(d);
if (!tok) return [];
let i = 0, curX = 0, curY = 0, lastCmd = '';
let subStartX = 0, subStartY = 0;
const segments = [];
const take = () => tok[i++];
const isCmd = t => /^[A-Za-z]$/.test(t);
const toAbs = (rel, x, y) => rel ? [curX + x, curY + y] : [x, y];
while (i < tok.length) {
let cmd = take();
if (!isCmd(cmd)) { i--; cmd = lastCmd; } else { lastCmd = cmd; }
const ABS = cmd.toUpperCase();
const rel = cmd !== ABS;
if (ABS === 'Z') {
segments.push({ cmd: 'Z' });
curX = subStartX;
curY = subStartY;
continue;
}
const nPer = SPEC[ABS];
if (!nPer) continue;
let buf = [];
while (i < tok.length && !isCmd(tok[i])) {
buf.push(parseFloat(take()));
if (buf.length % nPer === 0) {
const n = buf.splice(buf.length - nPer, nPer);
switch (ABS) {
case 'M': {
const [x, y] = toAbs(rel, n[0], n[1]);
segments.push({ cmd: 'M', x, y });
curX = x; curY = y;
subStartX = x; subStartY = y;
break;
}
case 'L': {
const [x, y] = toAbs(rel, n[0], n[1]);
segments.push({ cmd: 'L', x, y });
curX = x; curY = y;
break;
}
case 'H': {
const x = rel ? curX + n[0] : n[0];
segments.push({ cmd: 'H', x });
curX = x;
break;
}
case 'V': {
const y = rel ? curY + n[0] : n[0];
segments.push({ cmd: 'V', y });
curY = y;
break;
}
case 'C': {
const [x1, y1] = toAbs(rel, n[0], n[1]);
const [x2, y2] = toAbs(rel, n[2], n[3]);
const [x, y] = toAbs(rel, n[4], n[5]);
segments.push({ cmd: 'C', x1, y1, x2, y2, x, y });
curX = x; curY = y;
break;
}
case 'S': {
const [x2, y2] = toAbs(rel, n[0], n[1]);
const [x, y] = toAbs(rel, n[2], n[3]);
segments.push({ cmd: 'S', x2, y2, x, y });
curX = x; curY = y;
break;
}
case 'Q': {
const [x1, y1] = toAbs(rel, n[0], n[1]);
const [x, y] = toAbs(rel, n[2], n[3]);
segments.push({ cmd: 'Q', x1, y1, x, y });
curX = x; curY = y;
break;
}
case 'T': {
const [x, y] = toAbs(rel, n[0], n[1]);
segments.push({ cmd: 'T', x, y });
curX = x; curY = y;
break;
}
case 'A': {
const rx = n[0], ry = n[1], rot = n[2], laf = n[3], sf = n[4];
const [x, y] = toAbs(rel, n[5], n[6]);
segments.push({ cmd: 'A', rx, ry, rot, laf, sf, x, y });
curX = x; curY = y;
break;
}
}
}
}
}
return segments;
}
function writeAbsoluteSegmentsToPath(pathEl, segments) {
if (!pathEl || !Array.isArray(segments)) return;
const out = [];
segments.forEach(seg => {
switch (seg.cmd) {
case 'M':
out.push('M', r3(seg.x), r3(seg.y));
break;
case 'L':
out.push('L', r3(seg.x), r3(seg.y));
break;
case 'H':
out.push('H', r3(seg.x));
break;
case 'V':
out.push('V', r3(seg.y));
break;
case 'C':
out.push('C', r3(seg.x1), r3(seg.y1), r3(seg.x2), r3(seg.y2), r3(seg.x), r3(seg.y));
break;
case 'S':
out.push('S', r3(seg.x2), r3(seg.y2), r3(seg.x), r3(seg.y));
break;
case 'Q':
out.push('Q', r3(seg.x1), r3(seg.y1), r3(seg.x), r3(seg.y));
break;
case 'T':
out.push('T', r3(seg.x), r3(seg.y));
break;
case 'A':
out.push('A', seg.rx, seg.ry, seg.rot, seg.laf, seg.sf, r3(seg.x), r3(seg.y));
break;
case 'Z':
out.push('Z');
break;
}
});
pathEl.setAttribute('d', out.join(' ').replace(/\s+/g, ' ').trim());
}
function buildFrozenPathMeta(pathEl) {
if (!pathEl) return null;
const d = pathEl.getAttribute('d');
if (!d) return null;
const tok = parseTokens(d);
if (!tok) return null;
const segments = parsePathToAbsoluteSegments(pathEl);
let i = 0, lastCmd = '';
const tokenMap = [];
const take = () => tok[i++];
const isCmd = t => /^[A-Za-z]$/.test(t);
while (i < tok.length) {
let cmd = take();
if (!isCmd(cmd)) { i--; cmd = lastCmd; } else { lastCmd = cmd; }
const ABS = cmd.toUpperCase();
if (ABS === 'Z') {
tokenMap.push({ cmd: 'Z' });
continue;
}
const nPer = SPEC[ABS];
if (!nPer) continue;
let idxBuf = [];
while (i < tok.length && !isCmd(tok[i])) {
idxBuf.push(i);
take();
if (idxBuf.length % nPer === 0) {
const idxs = idxBuf.splice(idxBuf.length - nPer, nPer);
switch (ABS) {
case 'M':
case 'L':
case 'T':
tokenMap.push({ cmd: ABS, x: idxs[0], y: idxs[1] });
break;
case 'H':
tokenMap.push({ cmd: 'H', x: idxs[0] });
break;
case 'V':
tokenMap.push({ cmd: 'V', y: idxs[0] });
break;
case 'C':
tokenMap.push({ cmd:'C', x1:idxs[0], y1:idxs[1], x2:idxs[2], y2:idxs[3], x:idxs[4], y:idxs[5] });
break;
case 'S':
tokenMap.push({ cmd:'S', x2:idxs[0], y2:idxs[1], x:idxs[2], y:idxs[3] });
break;
case 'Q':
tokenMap.push({ cmd:'Q', x1:idxs[0], y1:idxs[1], x:idxs[2], y:idxs[3] });
break;
case 'A':
tokenMap.push({ cmd:'A', rx:idxs[0], ry:idxs[1], rot:idxs[2], laf:idxs[3], sf:idxs[4], x:idxs[5], y:idxs[6] });
break;
}
}
}
}
return {
signature: getCommandSignature(tok),
segments,
tokenMap
};
}
function ensureFrozenPath(pathEl) {
if (!pathEl) return null;
if (pathEl._frozenPathMeta) return pathEl._frozenPathMeta;
const d = pathEl.getAttribute('d');
if (!d) return null;
if (hasRelativeCommands(d)) {
const segments = parsePathToAbsoluteSegments(pathEl);
writeAbsoluteSegmentsToPath(pathEl, segments);
}
pathEl._frozenPathMeta = buildFrozenPathMeta(pathEl);
return pathEl._frozenPathMeta;
}
function clearFrozenMeta() {
Object.values(TARGETS).flat().forEach(sel => {
const el = svg.querySelector(sel);
if (el) delete el._frozenPathMeta;
});
}
function getPrevEndYRef(meta, segIndex) {
for (let i = segIndex - 1; i >= 0; i--) {
const seg = meta.segments[i];
if (!seg) continue;
switch (seg.cmd) {
case 'M':
case 'L':
case 'T':
case 'V':
case 'C':
case 'S':
case 'Q':
case 'A':
return { segIndex: i, field: 'y' };
case 'H':
case 'Z':
break;
}
}
return null;
}
function capturePathYRefs(pathEl, aabbRoot) {
const meta = ensureFrozenPath(pathEl);
if (!meta || !Array.isArray(meta.segments)) return [];
const refs = [];
const seen = new Set();
function add(segIndex, field) {
const key = segIndex + ':' + field;
if (seen.has(key)) return;
seen.add(key);
refs.push({ segIndex, field });
}
let curX = 0, curY = 0;
let subStartX = 0, subStartY = 0;
meta.segments.forEach((seg, segIndex) => {
switch (seg.cmd) {
case 'M':
if (isInsideRootAABB(pathEl, aabbRoot, seg.x, seg.y)) add(segIndex, 'y');
curX = seg.x; curY = seg.y; subStartX = seg.x; subStartY = seg.y;
break;
case 'L':
case 'T':
if (isInsideRootAABB(pathEl, aabbRoot, seg.x, seg.y)) add(segIndex, 'y');
curX = seg.x; curY = seg.y;
break;
case 'H': {
const endX = seg.x, endY = curY;
if (isInsideRootAABB(pathEl, aabbRoot, endX, endY)) {
const prevRef = getPrevEndYRef(meta, segIndex);
if (prevRef) add(prevRef.segIndex, prevRef.field);
}
curX = seg.x;
break;
}
case 'V':
if (isInsideRootAABB(pathEl, aabbRoot, curX, seg.y)) add(segIndex, 'y');
curY = seg.y;
break;
case 'C':
if (isInsideRootAABB(pathEl, aabbRoot, seg.x1, seg.y1)) add(segIndex, 'y1');
if (isInsideRootAABB(pathEl, aabbRoot, seg.x2, seg.y2)) add(segIndex, 'y2');
if (isInsideRootAABB(pathEl, aabbRoot, seg.x, seg.y)) add(segIndex, 'y');
curX = seg.x; curY = seg.y;
break;
case 'S':
if (isInsideRootAABB(pathEl, aabbRoot, seg.x2, seg.y2)) add(segIndex, 'y2');
if (isInsideRootAABB(pathEl, aabbRoot, seg.x, seg.y)) add(segIndex, 'y');
curX = seg.x; curY = seg.y;
break;
case 'Q':
if (isInsideRootAABB(pathEl, aabbRoot, seg.x1, seg.y1)) add(segIndex, 'y1');
if (isInsideRootAABB(pathEl, aabbRoot, seg.x, seg.y)) add(segIndex, 'y');
curX = seg.x; curY = seg.y;
break;
case 'A':
if (isInsideRootAABB(pathEl, aabbRoot, seg.x, seg.y)) add(segIndex, 'y');
curX = seg.x; curY = seg.y;
break;
case 'Z':
curX = subStartX; curY = subStartY;
break;
}
});
return refs;
}
function adjustPathYCaptured(pathEl, refs, delta) {
if (!pathEl || !Array.isArray(refs) || !refs.length || Math.abs(delta) < EPS) return;
const meta = ensureFrozenPath(pathEl);
if (!meta) return;
const d = pathEl.getAttribute('d');
if (!d) return;
const tok = parseTokens(d);
if (!tok) return;
if (getCommandSignature(tok) !== meta.signature) {
console.warn('Padstructuur gewijzigd; y-schuinte script slaat dit pad over:', pathEl.id);
return;
}
refs.forEach(ref => {
const map = meta.tokenMap[ref.segIndex];
if (!map || map[ref.field] == null) return;
const idx = map[ref.field];
const v = parseFloat(tok[idx]);
if (!isFinite(v)) return;
tok[idx] = String(r3(v + delta));
});
pathEl.setAttribute('d', tok.join(' ').replace(/\s+/g, ' ').trim());
}
// ===== Captures =====
let captures = {
BUVD: [],
KVT: [],
KVTPKU: [],
KVTPBU: [],
HS: []
};
function buildGroupCapture(selectors, rectEl) {
const aabb = rectAABBInRoot(rectEl);
if (!aabb) return [];
return selectors.map(sel => {
const el = svg.querySelector(sel);
if (!el) return null;
ensureFrozenPath(el);
return {
el,
refs: capturePathYRefs(el, aabb)
};
}).filter(Boolean);
}
function rebuildCaptures() {
clearFrozenMeta();
captures.BUVD = buildGroupCapture(TARGETS.BUVD, rBUVD);
captures.KVT = buildGroupCapture(TARGETS.KVT, rKVT);
captures.KVTPKU = rKVTPKU ? buildGroupCapture(TARGETS.KVTPKU, rKVTPKU) : [];
captures.KVTPBU = rKVTPBU ? buildGroupCapture(TARGETS.KVTPBU, rKVTPBU) : [];
captures.HS = buildGroupCapture(TARGETS.HS, rHS);
}
function applyGroupCapture(items, delta, divisor) {
if (!delta || !items.length) return;
const actualDelta = delta / divisor;
items.forEach(item => {
adjustPathYCaptured(item.el, item.refs, actualDelta);
});
}
// ===== Shiftbox verplaatsing =====
function moveShiftboxX(r, dx) {
if (!r || !dx) return;
r.setAttribute('x', r3((num(r.getAttribute('x')) || 0) - dx));
}
function moveShiftboxY_div(r, dy, div) {
if (!r || !dy) return;
r.setAttribute('y', r3((num(r.getAttribute('y')) || 0) + (dy / div)));
}
function moveAllShiftboxes(dx, dy) {
if (dx) {
moveShiftboxX(rBUVD, dx);
moveShiftboxX(rKVT, dx);
moveShiftboxX(rKVTPKU, dx);
moveShiftboxX(rKVTPBU, dx);
moveShiftboxX(rHS, dx);
}
if (dy) {
moveShiftboxY_div(rBUVD, dy, 12);
moveShiftboxY_div(rKVT, dy, 5.7);
moveShiftboxY_div(rKVTPKU, dy, 5.7);
moveShiftboxY_div(rKVTPBU, dy, 12);
moveShiftboxY_div(rHS, dy, 12);
}
}
// ===== Batch =====
function schedule() {
if (rafId) return;
rafId = requestAnimationFrame(() => {
if (pBu) applyGroupCapture(captures.BUVD, pBu, 12);
if (pKvt) applyGroupCapture(captures.KVT, pKvt, 5.7);
if (pKvtPku) applyGroupCapture(captures.KVTPKU, pKvtPku, 5.7);
if (pKvtPbu) applyGroupCapture(captures.KVTPBU, pKvtPbu, 12);
if (pHs) applyGroupCapture(captures.HS, pHs, 12);
if (pDx || pDy) moveAllShiftboxes(pDx, pDy);
if (pDyHSBox) moveShiftboxY_div(rHS, pDyHSBox, 12);
pDx = pDy = pBu = pKvt = pKvtPku = pKvtPbu = pHs = pDyHSBox = 0;
rafId = 0;
});
}
// ===== Handlers =====
function onDorpelbreedte(raw) {
const cur = num(raw);
if (!Number.isFinite(cur)) return;
const dx = cur - lastDB;
if (dx) pDx += dx;
lastDB = cur;
const dynMax = getDynMax();
$bu.setAttribute('max', dynMax);
$hs.setAttribute('max', dynMax);
const currBU = num($bu.value);
const effBU = clampValid(currBU, safeBU_MIN, dynMax, true, true, lastBU);
if (Number.isFinite(effBU) && effBU !== lastBU) {
const dy = effBU - lastBU;
pDy += dy;
pBu += dy;
pKvt += dy;
pKvtPku += dy;
pKvtPbu += dy;
pHs += dy;
lastBU = effBU;
if (currBU > dynMax) $bu.value = String(effBU);
}
const currHS = num($hs.value);
const effHS = clampValid(currHS, safeHS_MIN, dynMax, true, true, lastHS);
if (Number.isFinite(effHS) && effHS !== lastHS) {
const dy = effHS - lastHS;
pHs += dy;
pDyHSBox += dy;
lastHS = effHS;
if (currHS > dynMax) $hs.value = String(effHS);
}
schedule();
}
function onBUVD(raw) {
const dynMax = getDynMax();
const v = num(raw);
if (!Number.isFinite(v)) return;
if (v > dynMax) {
const eff = dynMax;
const dy = eff - lastBU;
if (dy) {
pDy += dy;
pBu += dy;
pKvt += dy;
pKvtPku += dy;
pKvtPbu += dy;
pHs += dy;
lastBU = eff;
$bu.value = String(eff);
schedule();
}
return;
}
if (v < safeBU_MIN) return;
const dy = v - lastBU;
if (!dy) return;
pDy += dy;
pBu += dy;
pKvt += dy;
pKvtPku += dy;
pKvtPbu += dy;
pHs += dy;
lastBU = v;
schedule();
}
function onHS(raw) {
const dynMax = getDynMax();
const v = num(raw);
if (!Number.isFinite(v)) return;
if (v > dynMax) {
const eff = dynMax;
const dy = eff - lastHS;
if (dy) {
pHs += dy;
pDyHSBox += dy;
lastHS = eff;
$hs.value = String(eff);
schedule();
}
return;
}
if (v < safeHS_MIN) return;
const dy = v - lastHS;
if (!dy) return;
pHs += dy;
pDyHSBox += dy;
lastHS = v;
schedule();
}
function rebuildAfterDorpeltypeChange() {
lastDB = num($db.value);
if (!Number.isFinite(lastDB)) lastDB = 0;
lastBU = clampValid(num($bu.value), safeBU_MIN, getDynMax(), true, true, safeBU_MIN);
lastHS = clampValid(num($hs.value), safeHS_MIN, getDynMax(), true, true, safeHS_MIN);
pDx = pDy = pBu = pKvt = pKvtPku = pKvtPbu = pHs = pDyHSBox = 0;
if (rafId) {
cancelAnimationFrame(rafId);
rafId = 0;
}
rebuildCaptures();
}
// ===== Listeners =====
$db.addEventListener('input', e => onDorpelbreedte(e.target.value));
$db.addEventListener('change', e => onDorpelbreedte(e.target.value));
$bu.addEventListener('input', e => onBUVD(e.target.value));
$bu.addEventListener('change', e => onBUVD(e.target.value));
$hs.addEventListener('input', e => onHS(e.target.value));
$hs.addEventListener('change', e => onHS(e.target.value));
document.addEventListener('change', e => {
const t = e.target;
if (t && t.matches && t.matches('input[name="form_fields[dorpeltype]"]')) {
setTimeout(() => {
requestAnimationFrame(() => requestAnimationFrame(() => {
rebuildAfterDorpeltypeChange();
}));
}, 70);
}
}, { passive: true });
// ===== Init =====
(function init() {
const dynMax = getDynMax();
$bu.setAttribute('max', dynMax);
$hs.setAttribute('max', dynMax);
rebuildCaptures();
})();
})();
//// BI BUVD KVT HS INVOERVELD WAARDE LIMIETEN ////
document.addEventListener('DOMContentLoaded', function () {
// ===========================
// SINGLETON CLEANUP
// ===========================
if (window.__DORPEL_RULES__?.destroy) {
try { window.__DORPEL_RULES__.destroy(); } catch(e) {}
}
const radios = Array.from(document.querySelectorAll('input[type="radio"][name="form_fields[dorpeltype]"]'));
const bwEl = document.getElementById('form-field-dorpelbreedte');
const biEl = document.getElementById('form-field-sponningdiepte_bi');
const buvdEl = document.getElementById('form-field-sponningdiepte_buvd');
if (!bwEl || !radios.length) return;
// ---------------- Helpers ----------------
const toNum = (v, fb = null) => {
const n = parseFloat(v);
return Number.isFinite(n) ? n : fb;
};
const clampNum = (v, lo, hi) => Math.min(Math.max(v, lo), hi);
const getStep = (el) => {
const s = parseFloat(el.step);
return Number.isFinite(s) && s > 0 ? s : 1;
};
const safeSetBound = (el, k, v) => {
const s = String(v);
if (el.getAttribute(k) !== s) el.setAttribute(k, s);
};
// ✅ EXTRA ABSOLUTE LIMIET
const ABS_SPON_MAX = 100;
function getSelectedType() {
const sel = radios.find(r => r.checked);
return sel ? (sel.getAttribute('data-original-value') || sel.dataset.originalValue || sel.value) : null;
}
// HS radio/label
const hsRadio = radios.find(
r => (r.getAttribute('data-original-value') || r.dataset.originalValue || r.value) === 'HS'
);
const hsLabel = hsRadio ? document.querySelector(`label[for="${hsRadio.id}"]`) : null;
// ---------------- HS eligibility ----------------
function hsEligibleNow() {
const bw = toNum(bwEl.value, null);
const buvd = toNum(buvdEl ? buvdEl.value : null, null);
if (bw === null || buvd === null) return false;
const rule1 = (bw >= 114);
const rule2 = ((bw - buvd) >= 47);
return rule1 && rule2;
}
function updateHsOptionLock() {
if (!hsRadio) return;
const type = getSelectedType();
const shouldDisableHS = (type !== 'HS') && !hsEligibleNow();
/*
hsRadio.disabled = !!shouldDisableHS;
if (hsLabel) {
hsLabel.style.opacity = shouldDisableHS ? '0.4' : '';
hsLabel.style.pointerEvents = shouldDisableHS ? 'none' : '';
}
*/
}
// ===========================
// VALID-ONLY INPUT / RULE MODES
// ===========================
function makeMode({ b, rule, enforceAbsMinA = null }) {
if (!b) return { enable(){}, disable(){} };
const base = {
aMin: toNum(bwEl.getAttribute('min'), -Infinity),
aMax: toNum(bwEl.getAttribute('max'), Infinity),
bMin: toNum(b.getAttribute('min'), -Infinity),
bMax: Math.min(toNum(b.getAttribute('max'), Infinity), ABS_SPON_MAX),
};
let enabled = false;
let raf = 0;
let lastAInputType = null;
function computeBounds() {
const bw = toNum(bwEl.value, null);
const sv = toNum(b.value, null);
let aMinEff, aMaxEff, bMinEff, bMaxEff;
const api = {
base, bw, sv,
setA(min, max) { aMinEff = min; aMaxEff = max; },
setB(min, max) { bMinEff = min; bMaxEff = max; }
};
const { bad, message } = rule(api);
if (enforceAbsMinA !== null) aMinEff = Math.max(aMinEff, enforceAbsMinA);
bMaxEff = Math.min(bMaxEff, ABS_SPON_MAX);
return { bw, sv, aMinEff, aMaxEff, bMinEff, bMaxEff, bad, message };
}
function recalc(activeEl, hardClamp) {
raf = 0;
const { bw, sv, aMinEff, aMaxEff, bMinEff, bMaxEff, bad, message } = computeBounds();
safeSetBound(bwEl, 'min', aMinEff);
safeSetBound(bwEl, 'max', aMaxEff);
safeSetBound(b, 'min', bMinEff);
safeSetBound(b, 'max', bMaxEff);
if (hardClamp && activeEl === bwEl && bw !== null) {
const nv = clampNum(bw, aMinEff, aMaxEff);
if (nv !== bw) bwEl.value = String(nv);
}
if (hardClamp && activeEl === b && sv !== null) {
const nv = clampNum(sv, bMinEff, bMaxEff);
if (nv !== sv) b.value = String(nv);
}
bwEl.setCustomValidity(bad ? message : '');
b.setCustomValidity(bad ? message : '');
const form = bwEl.closest('form');
const submit = form ? form.querySelector('[type="submit"]') : null;
if (submit) submit.disabled = !!bad;
updateHsOptionLock();
}
function schedule(activeEl, hardClamp = false) {
if (!enabled) return;
if (raf) cancelAnimationFrame(raf);
raf = requestAnimationFrame(() => recalc(activeEl, hardClamp));
}
function onAKeydown(e) {
if (e.key !== 'ArrowDown' && e.key !== 'ArrowUp') return;
const { aMinEff, aMaxEff } = computeBounds();
const step = getStep(bwEl);
const cur = toNum(bwEl.value, null);
if (cur === null) return;
const next = e.key === 'ArrowDown' ? cur - step : cur + step;
if (
(Number.isFinite(aMinEff) && next < aMinEff) ||
(Number.isFinite(aMaxEff) && next > aMaxEff)
) {
e.preventDefault();
e.stopPropagation();
}
}
function onABeforeInput(e) {
lastAInputType = e.inputType || null;
}
function onAInputCapture(e) {
const v = toNum(bwEl.value, null);
if (v === null) {
updateHsOptionLock();
return;
}
const { aMinEff, aMaxEff } = computeBounds();
const isTyping = (lastAInputType === 'insertText');
if (isTyping) {
if (Number.isFinite(aMaxEff) && v > aMaxEff) {
bwEl.value = String(aMaxEff);
queueMicrotask(() => bwEl.dispatchEvent(new Event('input', { bubbles: true })));
} else if (Number.isFinite(aMinEff) && v < aMinEff) {
e.stopImmediatePropagation();
}
} else {
const nv = clampNum(v, aMinEff, aMaxEff);
if (nv !== v) {
bwEl.value = String(nv);
queueMicrotask(() => bwEl.dispatchEvent(new Event('input', { bubbles: true })));
}
}
lastAInputType = null;
updateHsOptionLock();
}
function onBInputCapture(e) {
const v = toNum(b.value, null);
if (v === null) {
updateHsOptionLock();
return;
}
const { bMinEff, bMaxEff } = computeBounds();
if (Number.isFinite(bMaxEff) && v > bMaxEff) {
b.value = String(bMaxEff);
queueMicrotask(() => b.dispatchEvent(new Event('input', { bubbles: true })));
updateHsOptionLock();
return;
}
if (Number.isFinite(bMinEff) && v < bMinEff) {
e.stopImmediatePropagation();
}
updateHsOptionLock();
}
function enable() {
if (enabled) return;
enabled = true;
bwEl.addEventListener('keydown', onAKeydown, { capture: true });
bwEl.addEventListener('beforeinput', onABeforeInput);
bwEl.addEventListener('input', onAInputCapture, { capture: true });
bwEl.addEventListener('input', () => schedule(bwEl, false));
bwEl.addEventListener('change', () => schedule(bwEl, true));
bwEl.addEventListener('blur', () => schedule(bwEl, true));
b.addEventListener('input', onBInputCapture, { capture: true });
b.addEventListener('input', () => schedule(b, false));
b.addEventListener('change', () => schedule(b, true));
b.addEventListener('blur', () => schedule(b, true));
schedule(null, false);
updateHsOptionLock();
}
function disable() {
if (!enabled) return;
enabled = false;
if (raf) cancelAnimationFrame(raf);
raf = 0;
bwEl.removeEventListener('keydown', onAKeydown, { capture: true });
bwEl.removeEventListener('beforeinput', onABeforeInput);
bwEl.removeEventListener('input', onAInputCapture, { capture: true });
b.removeEventListener('input', onBInputCapture, { capture: true });
bwEl.setCustomValidity('');
b.setCustomValidity('');
updateHsOptionLock();
}
return { enable, disable };
}
// ---------------- Modes / rules ----------------
const modeBI = makeMode({
b: biEl,
rule: ({ base, bw, sv, setA, setB }) => {
const REQ = 32;
setA(Math.max(base.aMin, Number.isFinite(sv) ? sv + REQ : -Infinity), base.aMax);
setB(base.bMin, Math.min(base.bMax, Number.isFinite(bw) ? bw - REQ : Infinity));
const bad = Number.isFinite(bw) && Number.isFinite(sv) ? ((bw - sv) < REQ) : false;
return {
bad,
message: 'Voorwaarde: dorpelbreedte − sponningdiepte BI moet ≥ 32 zijn.'
};
}
});
const modeBUVD_KVT = makeMode({
b: buvdEl,
rule: ({ base, bw, sv, setA, setB }) => {
const REQ = 24;
setA(Math.max(base.aMin, Number.isFinite(sv) ? sv + REQ : -Infinity), base.aMax);
setB(base.bMin, Math.min(base.bMax, Number.isFinite(bw) ? bw - REQ : Infinity));
const bad = Number.isFinite(bw) && Number.isFinite(sv) ? ((bw - sv) < REQ) : false;
return {
bad,
message: 'Voorwaarde: dorpelbreedte − sponningdiepte BUVD moet ≥ 24 zijn.'
};
}
});
const modeHS = makeMode({
b: buvdEl,
enforceAbsMinA: 114,
rule: ({ base, bw, sv, setA, setB }) => {
const REQ = 47;
const ABS_MIN = 114;
let aMinEff = Math.max(base.aMin, Number.isFinite(sv) ? sv + REQ : -Infinity);
aMinEff = Math.max(aMinEff, ABS_MIN);
setA(aMinEff, base.aMax);
setB(base.bMin, Math.min(base.bMax, Number.isFinite(bw) ? bw - REQ : Infinity));
const both = Number.isFinite(bw) && Number.isFinite(sv);
const bad = both ? ((bw - sv) < REQ || bw < ABS_MIN) : false;
return {
bad,
message: 'Voorwaarde: dorpelbreedte − sponningdiepte moet ≥ 47 zijn en dorpelbreedte ≥ 114.'
};
}
});
const modesByType = {
BI: modeBI,
KVTPKI: modeBI,
BUVD: modeBUVD_KVT,
KVT: modeBUVD_KVT,
KVTPKU: modeBUVD_KVT,
KVTPBU: modeBUVD_KVT,
HS: modeHS
};
let activeMode = null;
function switchModeToSelected() {
const type = getSelectedType();
if (activeMode) activeMode.disable();
activeMode = type ? (modesByType[type] || null) : null;
if (activeMode) activeMode.enable();
updateHsOptionLock();
}
radios.forEach(r => r.addEventListener('change', switchModeToSelected));
bwEl.addEventListener('input', updateHsOptionLock);
buvdEl?.addEventListener('input', updateHsOptionLock);
// init
switchModeToSelected();
updateHsOptionLock();
window.__DORPEL_RULES__ = {
destroy() {
try { activeMode?.disable(); } catch(e) {}
}
};
});