mirror of
https://github.com/IliesAllali/parenthese.git
synced 2026-11-16 00:32:04 +00:00
Par convention, les généalogistes écrivent le nom en capitales pour le distinguer du prénom (« Bertrand GAUTHIER »). Paramètres de l'arbre > Affichage gagne une case « Les noms de famille en capitales », éteinte par défaut. Le réglage est celui de l'arbre : il est enregistré dans tree_settings (migration additive, false par défaut) et part avec le graphe, donc la famille qui ouvre le lien le voit comme les gestionnaires l'ont choisi. Seul l'affichage change : surnameLabel() met le nom en capitales partout où il s'affiche (arbre, fiche, recherche, onglets de familles, listes, propositions) et les champs Nom et Nom de naissance s'affichent en capitales pendant la saisie, mais le nom reste enregistré tel qu'il a été tapé. On peut éteindre le réglage sans rien perdre, et l'export GEDCOM ne change pas. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1379 lines
68 KiB
React
1379 lines
68 KiB
React
import { surnameLabel } from '../utils/personName.js'
|
|
import { memo, useEffect, useImperativeHandle, useRef, useState, useCallback } from 'react'
|
|
import { getPersonMedias, getParents, getChildren, getPersonUnions, persons as graphPersons, unions as graphUnions, filiations as graphFiliations } from '../data/mockData'
|
|
import { PERSON_R, FLOAT_SPEED, FLOAT_AMPLITUDE, REPULSION_RADIUS, REPULSION_STRENGTH, MAX_ORBIT_MEDIAS, ENTRANCE_NODE_DURATION, ENTRANCE_CAMERA_DURATION, ENTRANCE_CAMERA_FROM_SCALE, ENTRANCE_REDUCED_DURATION, ENTRANCE_LINE_DELAY, ENTRANCE_LINE_DURATION, ENTRANCE_ORBIT_DELAY, ENTRANCE_ORBIT_DURATION, ENTRANCE_ORBIT_STAGGER } from './galaxy/constants'
|
|
import { easeOutCubic } from './galaxy/utils'
|
|
import { generateNodeRandomData, coupleBarMeta, restoreCoupleBarMeta } from './galaxy/elkLayout'
|
|
import { computeBlockLayout, familyTabsOf, lineToFamily, subgraphOf, takeRootLayout } from './galaxy/blockLayout'
|
|
import { hasGhosts, withGhosts } from '../utils/ghosts'
|
|
|
|
import { findPathBFS } from './galaxy/pathfinding'
|
|
import { drawBackground, drawCoupleLinks, drawFiliations, drawAnnotations, drawPathHighlight, drawNodes, drawRenvoiPills, nodeRadius } from './galaxy/renderers'
|
|
import { buildSiblingGroups, moveInOrder, pickSlot, rubberBand, springStep, isSettled, buildOrderPayload, filiationsWithOrder } from './galaxy/siblingReorder'
|
|
import { annotations as annotationData, updateAnnotation as updateAnnotationInStore } from '../data/mockData'
|
|
import { anchorLegacy, layoutCenters, placeAnnotations, readAnchor } from './annotations/anchor'
|
|
import { useImageCache } from './galaxy/useImageCache'
|
|
import { useGalaxyInteractions } from './galaxy/useGalaxyInteractions'
|
|
import { t as tr } from '../i18n/index.js'
|
|
import './Galaxy.css'
|
|
|
|
// Assez bas pour cadrer un grand arbre entier à l'ouverture
|
|
// (le rendu à petite échelle reste bon marché grâce au niveau de détail selon le zoom)
|
|
const MIN_SCALE = 0.12
|
|
|
|
// Lissage exponentiel avec convergence exacte : renvoie la cible dès qu'on en est à moins de eps,
|
|
// sinon les états lissés n'atteignent jamais leur cible et la scène se redessine sans fin.
|
|
function approach(prev, target, k, eps = 1e-3) {
|
|
const next = prev + (target - prev) * k
|
|
return Math.abs(target - next) < eps ? target : next
|
|
}
|
|
const MAX_SCALE = 3.2
|
|
// Carte des familles : l'arbre s'efface entre ces deux échelles, les tuiles de familles apparaissent
|
|
// Ouverture sur la personne de départ quand l'arbre entier serait illisible
|
|
const FOCUS_MIN_READABLE_SCALE = 0.5
|
|
// Prénoms à 12 px (13 px à l'échelle 1) : en dessous, ils restent dessinés mais ne se lisent plus
|
|
const FOCUS_SCALE = 0.95
|
|
// Sous 768 px, la réglette de zoom reste ouverte en bas à gauche (ZoomControl.css) : la personne de départ se
|
|
// centre dans la largeur qu'elle laisse libre
|
|
const PHONE_SLIDER_BAND = 64
|
|
|
|
// Réordonner une fratrie : seuil avant de soulever à la souris, appui long au doigt
|
|
const REORDER_MOUSE_THRESHOLD = 4
|
|
const REORDER_TOUCH_SLOP = 8
|
|
const REORDER_LONG_PRESS_MS = 320
|
|
// Les frères et sœurs s'écartent sans rebond ; la personne lâchée se pose avec un léger rebond
|
|
const SHIFT_SPRING = { stiffness: 560, dampingRatio: 0.92 }
|
|
const DROP_SPRING = { stiffness: 480, dampingRatio: 0.72 }
|
|
const centerX = (node) => node.x + node.width / 2
|
|
// Recul de la caméra à l'ouverture : départ immédiat, long freinage (ease-out quint)
|
|
const easeOutQuint = (t) => 1 - (1 - t) ** 5
|
|
const prefersReducedMotion = () => typeof window !== 'undefined' && window.matchMedia?.('(prefers-reduced-motion: reduce)').matches
|
|
|
|
// Barre des familles rangée comme l'arbre (Patch, 28/10, planche A variante 2 « le trait d'union ») : chaque
|
|
// famille juste après celle par laquelle on y entre, la famille de départ en tête. Les onglets d'une même branche
|
|
// (sous-arbre d'un enfant direct de la famille de départ) se serrent à 10 px, 16 px entre les branches ; un trait
|
|
// relie deux voisins quand le second part du premier (jamais vers la famille de départ, sa place en tête suffit).
|
|
// Le trait qui mène à l'onglet ouvert est terracotta, les autres couleur fil.
|
|
function barTabs(tabs, activeKey) {
|
|
if (!tabs.length) return []
|
|
const root = tabs[0]
|
|
const kids = new Map()
|
|
for (const tb of tabs.slice(1)) { const pk = tabs.some((x) => x.key === tb.parentKey) ? tb.parentKey : root.key; if (!kids.has(pk)) kids.set(pk, []); kids.get(pk).push(tb) }
|
|
const order = []
|
|
const visit = (tb) => { order.push(tb); for (const c of kids.get(tb.key) || []) visit(c) }
|
|
visit(root)
|
|
for (const tb of tabs) if (!order.includes(tb)) order.push(tb)
|
|
const byKey = new Map(tabs.map((tb) => [tb.key, tb]))
|
|
const pathTo = (tb) => { const out = []; for (let t = tb; t; t = byKey.get(t.parentKey)) out.unshift(t.key); return out }
|
|
const branchOf = (tb) => { const p = pathTo(tb); return p[1] || p[0] }
|
|
const active = byKey.get(activeKey) || root
|
|
const lit = new Set(pathTo(active))
|
|
return order.map((tb, i) => {
|
|
const prev = order[i - 1]
|
|
const gap = i === 0 ? 0 : (prev !== root && branchOf(tb) === branchOf(prev) ? 10 : 16)
|
|
const trait = i > 0 && prev !== root && tb.parentKey === prev.key ? (lit.has(tb.key) ? 'on' : 'off') : null
|
|
return { tb, gap, trait }
|
|
})
|
|
}
|
|
|
|
const Galaxy = ({ onPersonSelect, onMediaSelect, selectedPersonId, searchHighlightIds = [], graphRevision = 0, annotationHandlers = null, transformReadRef = null, zoomApiRef = null, focusPersonId = null, assetRevision = 0, reorderEnabled = false, onReorderSiblings = null, familyTabs = true, fullNames = false, surnameUppercase = false, annotationViewRef = null, onAnnotationsAnchored = null, selfPersonId = null, ghosts = null, initialFamilyKey = null, onFamilyChange = null }) => {
|
|
const canvasRef = useRef(null)
|
|
const layoutDataRef = useRef(null)
|
|
// Onglets de familles (réglage `familyTabs`) : la liste des familles de l'arbre, calculée une fois par
|
|
// version du graphe et par personne de départ, et l'onglet ouvert. Un onglet est le sous-arbre d'une
|
|
// grande belle-famille, posé avec le conjoint charnière comme référence.
|
|
const [tabs, setTabs] = useState([])
|
|
const [activeKey, setActiveKey] = useState(focusPersonId != null ? String(focusPersonId) : null)
|
|
const tabsCacheRef = useRef({ rev: -1, start: undefined, tabs: [] })
|
|
// Liste des onglets calculée dans un worker (galaxy/familyTabsWorker.js) quand l'arbre affiché est celui de la
|
|
// famille de départ : il ne dépend pas de cette liste, il s'affiche tout de suite et la barre suit. Une demande
|
|
// en cours est abandonnée (worker arrêté) dès qu'une autre part ou qu'on calcule la liste sur place.
|
|
const tabsRequestRef = useRef(null) // { rev, start, worker }
|
|
const cancelTabsRequest = useCallback(() => {
|
|
tabsRequestRef.current?.worker.terminate()
|
|
tabsRequestRef.current = null
|
|
}, [])
|
|
useEffect(() => cancelTabsRequest, [cancelTabsRequest])
|
|
const pendingFocusRef = useRef(null) // personne cherchée dans un autre onglet, visée après le changement
|
|
const pendingFrameRef = useRef(null) // personnes à cadrer une fois l'arbre reposé (ajout de plusieurs prénoms)
|
|
// Lien d'un onglet (?famille=<charnière>) : ouvert dès que l'arbre et ses onglets sont connus, et de nouveau si
|
|
// la personne de départ arrive après (visiteur), tant qu'on n'a pas soi-même changé d'onglet
|
|
const linkFamilyRef = useRef(initialFamilyKey != null ? String(initialFamilyKey) : null)
|
|
const pendingFamilyRef = useRef(initialFamilyKey != null ? String(initialFamilyKey) : null)
|
|
// Famille du lien sans onglet dans ce navigateur (onglets coupés) : l'arbre entier s'ouvre sur sa charnière
|
|
const frameOnRef = useRef(null)
|
|
const onFamilyChangeRef = useRef(onFamilyChange)
|
|
useEffect(() => { onFamilyChangeRef.current = onFamilyChange }, [onFamilyChange])
|
|
const activeTabRef = useRef(null)
|
|
const familyTabsRef = useRef(familyTabs)
|
|
useEffect(() => { familyTabsRef.current = familyTabs }, [familyTabs])
|
|
// Propositions pas encore relues (utils/ghosts.js) : placées et dessinées en transparence, jamais dans les données
|
|
const ghostsRef = useRef(ghosts)
|
|
const fullNamesRef = useRef(fullNames)
|
|
useEffect(() => { fullNamesRef.current = fullNames; needsRedrawRef.current = true }, [fullNames])
|
|
// Noms en capitales : le libellé se relit au dessin (surnameLabel), il suffit de redessiner
|
|
useEffect(() => { needsRedrawRef.current = true }, [surnameUppercase])
|
|
useEffect(() => { ghostsRef.current = ghosts; needsRedrawRef.current = true }, [ghosts])
|
|
const onAnnotationsAnchoredRef = useRef(onAnnotationsAnchored)
|
|
useEffect(() => { onAnnotationsAnchoredRef.current = onAnnotationsAnchored }, [onAnnotationsAnchored])
|
|
const startRefRef = useRef(focusPersonId)
|
|
useEffect(() => {
|
|
startRefRef.current = focusPersonId
|
|
if (linkFamilyRef.current != null) pendingFamilyRef.current = linkFamilyRef.current
|
|
setActiveKey(focusPersonId != null ? String(focusPersonId) : null)
|
|
}, [focusPersonId])
|
|
// Onglet choisi par la personne (barre, badge, recherche) : le lien d'arrivée ne s'impose plus
|
|
// Repère du changement d'onglet (Patch, 28/10 : « on perd un peu rapidement le fil ») : la personne qui relie
|
|
// les deux familles garde sa place et son zoom à l'écran, seules les familles autour changent
|
|
const anchorRef = useRef(null)
|
|
const linkPeople = (key) => {
|
|
const list = tabsCacheRef.current.tabs
|
|
const target = list.find((tb) => tb.key === String(key)), cur = activeTabRef.current || list[0]
|
|
return [target?.referenceId, ...(target?.hinges || []), cur?.referenceId, ...(cur?.hinges || [])].filter((x) => x != null).map(String)
|
|
}
|
|
const rememberAnchor = (key) => {
|
|
const layout = layoutDataRef.current, t = transformRef.current
|
|
if (!layout || !t) return
|
|
const ids = linkPeople(key)
|
|
const node = layout.children.find((n) => n._type === 'person' && ids.includes(String(n._data?.id)))
|
|
anchorRef.current = node ? { id: String(node._data.id), sx: (node.x + node.width / 2) * t.scale + t.x, sy: (node.y + node.height / 2) * t.scale + t.y, scale: t.scale } : null
|
|
}
|
|
const chooseTab = useCallback((key) => { rememberAnchor(key); linkFamilyRef.current = null; pendingFamilyRef.current = null; frameOnRef.current = null; setActiveKey(key) }, [])
|
|
// Survol d'un onglet : la personne par qui l'on y passe s'allume dans l'arbre affiché, sans texte (Patch : « que ça les suggère »)
|
|
const hoverTab = (key) => {
|
|
const layout = layoutDataRef.current
|
|
if (!layout) return
|
|
const present = new Set(layout.children.filter((n) => n._type === 'person').map((n) => String(n._data?.id)))
|
|
const ids = linkPeople(key).filter((id) => present.has(id))
|
|
searchHighlightSetRef.current = new Set([...searchHighlightIdsRef.current.map((id) => `p-${id}`), ...ids.map((id) => `p-${id}`)])
|
|
needsRedrawRef.current = true
|
|
}
|
|
const leaveTab = () => { searchHighlightSetRef.current = new Set(searchHighlightIdsRef.current.map((id) => `p-${id}`)); needsRedrawRef.current = true }
|
|
// Lu au calcul du cadrage et par le réordonnancement : la référence de l'arbre affiché
|
|
const focusPersonIdRef = useRef(focusPersonId)
|
|
// La barre défile quand les onglets débordent : l'onglet ouvert se met en vue (sans animation) et les bords
|
|
// coupés se signalent par un fondu
|
|
const tabsBarRef = useRef(null)
|
|
const [tabsEdges, setTabsEdges] = useState('')
|
|
const updateTabsEdges = useCallback(() => {
|
|
const el = tabsBarRef.current
|
|
if (!el) return
|
|
const left = el.scrollLeft > 12, right = el.scrollLeft + el.clientWidth < el.scrollWidth - 12
|
|
setTabsEdges(`${left ? ' has-left' : ''}${right ? ' has-right' : ''}`)
|
|
}, [])
|
|
useEffect(() => {
|
|
document.querySelector('.family-tab.is-active')?.scrollIntoView({ behavior: 'auto', inline: 'nearest', block: 'nearest' })
|
|
updateTabsEdges()
|
|
window.addEventListener('resize', updateTabsEdges)
|
|
return () => window.removeEventListener('resize', updateTabsEdges)
|
|
}, [activeKey, tabs, updateTabsEdges])
|
|
// Clic sur un badge : l'onglet de cette famille (ou, depuis un onglet, celui d'où l'on vient)
|
|
const openFamily = useCallback((tabKey) => { if (tabKey != null) chooseTab(String(tabKey)) }, [chooseTab])
|
|
// Propriétaire : un portrait vide survolé montre « + photo »
|
|
const [layoutReady, setLayoutReady] = useState(false)
|
|
const transformRef = useRef({ x: 0, y: 0, scale: 1 })
|
|
|
|
// Expose transformRef to parent so it can compute world coords (e.g. for photo placement)
|
|
if (transformReadRef) transformReadRef.current = transformRef
|
|
const targetTransformRef = useRef({ x: 0, y: 0, scale: 1 })
|
|
const initialTransformRef = useRef(null)
|
|
const mouseWorldPos = useRef({ x: -9999, y: -9999 })
|
|
const dprRef = useRef(1)
|
|
const pinchRef = useRef(null) // { dist, center }
|
|
const nodeRandomDataRef = useRef(new Map())
|
|
const hoveredNodeId = useRef(null)
|
|
const hoveredMediaKey = useRef(null)
|
|
const hoverScales = useRef(new Map())
|
|
const mediaHoverState = useRef(new Map())
|
|
const dragLiftProgress = useRef(0)
|
|
const entranceRef = useRef(null)
|
|
// Arbre déjà ouvert dans cette page (sa première personne) : l'entrée ne se joue qu'à la première ouverture,
|
|
// un arbre modifié ou un autre onglet s'affiche net
|
|
const openedTreeRef = useRef(null)
|
|
const selectedPersonIdRef = useRef(null)
|
|
const selectedGlowScales = useRef(new Map())
|
|
const searchGlowScales = useRef(new Map())
|
|
const searchHighlightSetRef = useRef(new Set())
|
|
const immediateRelativesRef = useRef(new Set())
|
|
const pathEdgesRef = useRef([])
|
|
const pathNodesRef = useRef([])
|
|
const pathLabelRef = useRef('')
|
|
const pathProgressRef = useRef(new Map())
|
|
const pathLabelAlpha = useRef(0)
|
|
const pathStartTime = useRef(-1)
|
|
const lastPathInputRef = useRef({ selected: null, hovered: null })
|
|
const [displayLabel, setDisplayLabel] = useState('')
|
|
const displayLabelRef = useRef('')
|
|
|
|
// Réordonner une fratrie (mode édition, administrateurs) : décalage animé de chaque nœud vers sa place
|
|
// dans le placement affiché, état du geste en cours, soulèvement de la personne tenue
|
|
const offsetsRef = useRef(new Map())
|
|
const reorderRef = useRef(null)
|
|
const liftScalesRef = useRef(new Map())
|
|
const groupsCacheRef = useRef({ layout: null, groups: new Map() })
|
|
const lastFrameRef = useRef(0)
|
|
const reorderEnabledRef = useRef(reorderEnabled)
|
|
const onReorderRef = useRef(onReorderSiblings)
|
|
useEffect(() => { reorderEnabledRef.current = reorderEnabled }, [reorderEnabled])
|
|
useEffect(() => { onReorderRef.current = onReorderSiblings }, [onReorderSiblings])
|
|
|
|
// Rendu à la demande : la boucle rAF tourne mais ne redessine que si quelque chose a changé
|
|
// (transform, états lissés, entrée, souris, annotations, image chargée, rendu React, resize).
|
|
const needsRedrawRef = useRef(true)
|
|
const lastAnnotationDataRef = useRef(null)
|
|
const markDirty = useCallback(() => { needsRedrawRef.current = true }, [])
|
|
useEffect(() => { needsRedrawRef.current = true })
|
|
|
|
const imageCache = useImageCache(`${graphRevision}:${assetRevision}`, markDirty)
|
|
|
|
// Position animée d'un nœud
|
|
const getAnimatedPos = useCallback((node, time) => {
|
|
const baseCx = node.x + node.width / 2 + (offsetsRef.current.get(node.id)?.x || 0)
|
|
const baseCy = node.y + node.height / 2
|
|
const rd = nodeRandomDataRef.current.get(node.id)
|
|
if (!rd) return { cx: baseCx, cy: baseCy }
|
|
|
|
let cx = baseCx + rd.offsetX
|
|
let cy = baseCy + rd.offsetY
|
|
|
|
cx += Math.sin(time * rd.floatSpeedX + rd.floatPhaseX) * rd.floatAmpX
|
|
cy += Math.sin(time * rd.floatSpeedY + rd.floatPhaseY) * rd.floatAmpY
|
|
|
|
if ((node._type === 'person' || node._type === 'unknown') && reorderRef.current?.phase !== 'dragging') {
|
|
const mouse = mouseWorldPos.current
|
|
const dx = cx - mouse.x
|
|
const dy = cy - mouse.y
|
|
const dist = Math.sqrt(dx * dx + dy * dy)
|
|
if (dist < REPULSION_RADIUS && dist > 1) {
|
|
const force = (1 - dist / REPULSION_RADIUS) * REPULSION_STRENGTH
|
|
cx += (dx / dist) * force
|
|
cy += (dy / dist) * force
|
|
}
|
|
}
|
|
|
|
return { cx, cy }
|
|
}, [])
|
|
|
|
const {
|
|
isDragging, isZooming, zoomTimeoutRef, hasDragged,
|
|
handleMouseDown, handleMouseMove, handleMouseUp,
|
|
handleMouseLeave, handleWheel, handleClick,
|
|
} = useGalaxyInteractions({
|
|
canvasRef, transformRef, targetTransformRef,
|
|
layoutDataRef, nodeRandomDataRef, entranceRef,
|
|
hoveredNodeIdRef: hoveredNodeId, hoveredMediaKeyRef: hoveredMediaKey, mouseWorldPosRef: mouseWorldPos,
|
|
getAnimatedPos, onPersonSelect, onMediaSelect, onOpenFamily: openFamily,
|
|
annotationHandlers,
|
|
minScale: MIN_SCALE,
|
|
maxScale: MAX_SCALE,
|
|
})
|
|
|
|
// ---------- Réordonner une fratrie ----------
|
|
// Le glisser ne déplace une personne qu'à l'horizontale, parmi ses frères et sœurs. Pour chaque place visée,
|
|
// le vrai placement est recalculé : l'arbre se réarrange pendant le geste et rien ne saute au lâcher.
|
|
const getSiblingGroups = useCallback(() => {
|
|
const layout = layoutDataRef.current
|
|
if (groupsCacheRef.current.layout !== layout) groupsCacheRef.current = { layout, groups: buildSiblingGroups(layout) }
|
|
return groupsCacheRef.current.groups
|
|
}, [])
|
|
|
|
const canReorderNow = useCallback(() => (
|
|
reorderEnabledRef.current && Boolean(layoutDataRef.current) && Boolean(entranceRef.current?.finished)
|
|
), [])
|
|
|
|
const worldX = useCallback((clientX) => {
|
|
const rect = canvasRef.current?.getBoundingClientRect()
|
|
const t = transformRef.current
|
|
return rect ? (clientX - rect.left - t.x) / t.scale : 0
|
|
}, [])
|
|
|
|
// Personne réordonnable sous le pointeur
|
|
const reorderTargetAt = useCallback((clientX, clientY) => {
|
|
if (!canReorderNow()) return null
|
|
const rect = canvasRef.current?.getBoundingClientRect()
|
|
if (!rect) return null
|
|
const t = transformRef.current
|
|
const wx = (clientX - rect.left - t.x) / t.scale
|
|
const wy = (clientY - rect.top - t.y) / t.scale
|
|
const groups = getSiblingGroups()
|
|
const now = performance.now()
|
|
for (const node of layoutDataRef.current.children) {
|
|
if (node._type !== 'person' || !groups.has(node.id)) continue
|
|
const pos = getAnimatedPos(node, now)
|
|
if (Math.hypot(pos.cx - wx, pos.cy - wy) < nodeRadius(node)) return node
|
|
}
|
|
return null
|
|
}, [canReorderNow, getSiblingGroups, getAnimatedPos])
|
|
|
|
// Placement complet pour un ordre de la fratrie, recalé sur la source (les parents ne bougent pas)
|
|
const layoutForOrder = useCallback((group, order, base) => {
|
|
const tab = activeTabRef.current
|
|
const tabSrc = tab?.personIds ? subgraphOf(tab.personIds) : null
|
|
const src = withGhosts(tabSrc || { persons: graphPersons, unions: graphUnions, filiations: graphFiliations }, ghostsRef.current, !tabSrc)
|
|
const graph = {
|
|
persons: src.persons,
|
|
unions: src.unions,
|
|
filiations: filiationsWithOrder(src.filiations, src.unions, group.source, order),
|
|
}
|
|
const result = computeBlockLayout(graph, focusPersonIdRef.current, { familyTabs: familyTabsRef.current })
|
|
const baseSource = base.children.find((n) => n.id === group.source)
|
|
const source = result.children.find((n) => n.id === group.source)
|
|
const shift = baseSource && source ? baseSource.x - source.x : 0
|
|
if (shift) result.children.forEach((n) => { n.x += shift })
|
|
return result
|
|
}, [])
|
|
|
|
// Remplace le placement affiché : chaque nœud garde sa position à l'écran puis glisse vers sa nouvelle place
|
|
const swapLayout = useCallback((next, frontId = null) => {
|
|
const prev = layoutDataRef.current
|
|
if (!prev || !next) return
|
|
const prevById = new Map(prev.children.map((n) => [n.id, n]))
|
|
const offsets = offsetsRef.current
|
|
const reduce = prefersReducedMotion()
|
|
for (const node of next.children) {
|
|
const old = prevById.get(node.id)
|
|
if (!old) continue
|
|
const current = offsets.get(node.id)
|
|
const delta = old.x + (current?.x || 0) - node.x
|
|
if (reduce && node.id !== frontId) { offsets.delete(node.id); continue }
|
|
if (Math.abs(delta) > 0.01 || current) offsets.set(node.id, { x: delta, v: current?.v || 0, spring: current?.spring || SHIFT_SPRING })
|
|
}
|
|
if (frontId) {
|
|
const i = next.children.findIndex((n) => n.id === frontId)
|
|
if (i >= 0) next.children.push(...next.children.splice(i, 1))
|
|
}
|
|
layoutDataRef.current = next
|
|
needsRedrawRef.current = true
|
|
}, [])
|
|
|
|
// Envoie l'ordre ; en cas d'échec, l'arbre revient en glissant à l'ordre précédent
|
|
const commitOrder = useCallback((group, order, base) => {
|
|
const payload = buildOrderPayload(graphFiliations, graphUnions, group.source, order)
|
|
const result = onReorderRef.current?.(payload)
|
|
if (result && typeof result.catch === 'function') {
|
|
result.catch(() => { if (!reorderRef.current) swapLayout(base) })
|
|
}
|
|
}, [swapLayout])
|
|
|
|
const reorderWindowListeners = useRef(null)
|
|
|
|
const endReorder = useCallback((commit) => {
|
|
const drag = reorderRef.current
|
|
if (reorderWindowListeners.current) {
|
|
window.removeEventListener('mousemove', reorderWindowListeners.current.move)
|
|
window.removeEventListener('mouseup', reorderWindowListeners.current.up)
|
|
reorderWindowListeners.current = null
|
|
}
|
|
if (!drag) return
|
|
clearTimeout(drag.timer)
|
|
reorderRef.current = null
|
|
if (drag.phase !== 'dragging') return
|
|
const offset = offsetsRef.current.get(drag.nodeId)
|
|
if (offset) offsetsRef.current.set(drag.nodeId, { ...offset, v: 0, spring: DROP_SPRING })
|
|
if (canvasRef.current) canvasRef.current.style.cursor = 'grab'
|
|
if (!commit) {
|
|
swapLayout(drag.base, drag.nodeId)
|
|
} else if (drag.index !== drag.originalIndex) {
|
|
commitOrder(drag.group, moveInOrder(drag.group.ids, drag.nodeId, drag.index), drag.base)
|
|
}
|
|
needsRedrawRef.current = true
|
|
}, [swapLayout, commitOrder])
|
|
|
|
const updateReorder = useCallback((clientX) => {
|
|
const drag = reorderRef.current
|
|
if (drag?.phase !== 'dragging') return
|
|
const slots = drag.slots
|
|
drag.targetCenter = rubberBand(worldX(clientX) - drag.grab, slots[0], slots[slots.length - 1])
|
|
const index = pickSlot(slots, drag.targetCenter, drag.index)
|
|
if (index !== drag.index) {
|
|
drag.index = index
|
|
if (!drag.layouts.has(index)) drag.layouts.set(index, layoutForOrder(drag.group, moveInOrder(drag.group.ids, drag.nodeId, index), drag.base))
|
|
swapLayout(drag.layouts.get(index), drag.nodeId)
|
|
}
|
|
needsRedrawRef.current = true
|
|
}, [worldX, layoutForOrder, swapLayout])
|
|
|
|
const startReorder = useCallback((clientX) => {
|
|
const press = reorderRef.current
|
|
const base = layoutDataRef.current
|
|
const group = press && getSiblingGroups().get(press.nodeId)
|
|
const node = group && base.children.find((n) => n.id === press.nodeId)
|
|
if (!node) { reorderRef.current = null; return }
|
|
clearTimeout(press.timer)
|
|
const byId = new Map(base.children.map((n) => [n.id, n]))
|
|
const index = group.ids.indexOf(press.nodeId)
|
|
const visualCenter = centerX(node) + (offsetsRef.current.get(node.id)?.x || 0)
|
|
reorderRef.current = {
|
|
phase: 'dragging',
|
|
nodeId: press.nodeId,
|
|
group,
|
|
base,
|
|
slots: group.ids.map((id) => centerX(byId.get(id))),
|
|
index,
|
|
originalIndex: index,
|
|
layouts: new Map([[index, base]]),
|
|
grab: worldX(clientX) - visualCenter,
|
|
targetCenter: visualCenter,
|
|
pointer: press.pointer,
|
|
}
|
|
swapLayout(base, press.nodeId)
|
|
// Le geste n'est ni un panoramique ni un clic
|
|
isDragging.current = false
|
|
hasDragged.current = true
|
|
hoveredNodeId.current = null
|
|
if (canvasRef.current) canvasRef.current.style.cursor = 'grabbing'
|
|
if (press.pointer === 'touch') navigator.vibrate?.(8)
|
|
if (press.pointer === 'mouse') {
|
|
const move = (e) => updateReorder(e.clientX)
|
|
const up = () => endReorder(true)
|
|
reorderWindowListeners.current = { move, up }
|
|
window.addEventListener('mousemove', move)
|
|
window.addEventListener('mouseup', up)
|
|
}
|
|
}, [getSiblingGroups, worldX, swapLayout, updateReorder, endReorder, isDragging, hasDragged])
|
|
|
|
// Appui sur une personne réordonnable : la souris attend quelques pixels, le doigt un appui long
|
|
const beginReorderPress = useCallback((clientX, clientY, pointer) => {
|
|
const node = reorderTargetAt(clientX, clientY)
|
|
if (!node) return false
|
|
const press = { phase: 'pressing', nodeId: node.id, pointer, startX: clientX, startY: clientY, lastX: clientX, timer: null }
|
|
if (pointer === 'touch') press.timer = setTimeout(() => { if (reorderRef.current === press) startReorder(press.lastX) }, REORDER_LONG_PRESS_MS)
|
|
reorderRef.current = press
|
|
return true
|
|
}, [reorderTargetAt, startReorder])
|
|
|
|
// Flèches de la fiche : même animation, une place à gauche ou à droite
|
|
const moveSibling = useCallback((personId, delta) => {
|
|
if (reorderRef.current || !canReorderNow()) return false
|
|
const nodeId = `p-${personId}`
|
|
const group = getSiblingGroups().get(nodeId)
|
|
if (!group) return false
|
|
const index = group.ids.indexOf(nodeId)
|
|
const target = index + delta
|
|
if (target < 0 || target >= group.ids.length) return false
|
|
const base = layoutDataRef.current
|
|
const order = moveInOrder(group.ids, nodeId, target)
|
|
swapLayout(layoutForOrder(group, order, base), nodeId)
|
|
commitOrder(group, order, base)
|
|
return true
|
|
}, [canReorderNow, getSiblingGroups, swapLayout, layoutForOrder, commitOrder])
|
|
|
|
const getSiblingPlace = useCallback((personId) => {
|
|
if (!layoutDataRef.current) return null
|
|
const group = getSiblingGroups().get(`p-${personId}`)
|
|
return group ? { index: group.ids.indexOf(`p-${personId}`), count: group.ids.length } : null
|
|
}, [getSiblingGroups])
|
|
|
|
// Échap annule le glisser en cours
|
|
useEffect(() => {
|
|
const onKey = (e) => { if (e.key === 'Escape' && reorderRef.current?.phase === 'dragging') endReorder(false) }
|
|
window.addEventListener('keydown', onKey)
|
|
return () => window.removeEventListener('keydown', onKey)
|
|
}, [endReorder])
|
|
|
|
// Sortie du mode édition pendant un geste : on annule
|
|
useEffect(() => { if (!reorderEnabled && reorderRef.current) endReorder(false) }, [reorderEnabled, endReorder])
|
|
|
|
// Expose zoom API to parent (ZoomControl component), posée au commit et non pendant le rendu
|
|
useImperativeHandle(zoomApiRef, () => ({
|
|
zoomTo: (newScale) => {
|
|
const canvas = canvasRef.current
|
|
if (!canvas) return
|
|
const rect = canvas.getBoundingClientRect()
|
|
const cx = rect.width / 2
|
|
const cy = rect.height / 2
|
|
const base = targetTransformRef.current
|
|
const clamped = Math.min(MAX_SCALE, Math.max(MIN_SCALE, newScale))
|
|
const ratio = clamped / base.scale
|
|
targetTransformRef.current = {
|
|
scale: clamped,
|
|
x: cx - ratio * (cx - base.x),
|
|
y: cy - ratio * (cy - base.y),
|
|
}
|
|
},
|
|
resetZoom: () => {
|
|
if (initialTransformRef.current) {
|
|
targetTransformRef.current = { ...initialTransformRef.current }
|
|
}
|
|
},
|
|
// Recherche : glisse jusqu'à la personne, dans la partie de l'écran que la fiche ne couvre pas
|
|
// (fiche à gauche sur ordinateur, 408 px ; par le bas sur téléphone)
|
|
focusPerson: (personId) => {
|
|
const canvas = canvasRef.current
|
|
const node = layoutDataRef.current?.children.find(n => n.id === `p-${personId}`)
|
|
// Rangée dans un autre onglet : on ouvre cet onglet, la personne est visée une fois l'arbre posé
|
|
if (!node && familyTabsRef.current) {
|
|
const id = String(personId)
|
|
const all = tabsCacheRef.current.tabs
|
|
const home = all.find((tb) => tb.personIds?.has(id) && !(tb.hinges || []).map(String).includes(id)) || all.find((tb) => tb.personIds?.has(id)) || all[0]
|
|
if (home && home.key !== activeTabRef.current?.key) { pendingFocusRef.current = id; chooseTab(home.key) }
|
|
return
|
|
}
|
|
if (!canvas || !node) return
|
|
const rect = canvas.getBoundingClientRect()
|
|
const pos = getAnimatedPos(node, performance.now())
|
|
const scale = Math.min(MAX_SCALE, Math.max(targetTransformRef.current.scale, 1))
|
|
const phone = rect.width <= 768
|
|
const screenX = phone ? rect.width / 2 : (408 + rect.width) / 2
|
|
const screenY = phone ? rect.height * 0.22 : rect.height / 2
|
|
targetTransformRef.current = { scale, x: screenX - pos.cx * scale, y: screenY - pos.cy * scale }
|
|
},
|
|
// Plusieurs personnes venant d'être ajoutées : toutes dans le champ, au-dessus de la barre du bas. Si l'arbre
|
|
// n'est pas encore reposé avec elles, le cadrage attend la prochaine mise en place.
|
|
focusPersons: (personIds) => {
|
|
const canvas = canvasRef.current
|
|
const wanted = new Set(personIds.map((id) => `p-${id}`))
|
|
const nodes = (layoutDataRef.current?.children || []).filter((n) => wanted.has(n.id))
|
|
if (!canvas || nodes.length < personIds.length) { pendingFrameRef.current = personIds; return }
|
|
pendingFrameRef.current = null
|
|
const rect = canvas.getBoundingClientRect()
|
|
const now = performance.now()
|
|
const centers = nodes.map((n) => getAnimatedPos(n, now))
|
|
const xs = centers.map((p) => p.cx)
|
|
const ys = centers.map((p) => p.cy)
|
|
const margin = 140 // un portrait et son prénom
|
|
const fit = Math.min((rect.width - 32) / (Math.max(...xs) - Math.min(...xs) + margin), (rect.height * 0.6) / (Math.max(...ys) - Math.min(...ys) + margin))
|
|
const scale = Math.min(MAX_SCALE, Math.max(MIN_SCALE, Math.min(Math.max(targetTransformRef.current.scale, 1), fit)))
|
|
const cx = (Math.min(...xs) + Math.max(...xs)) / 2
|
|
const cy = (Math.min(...ys) + Math.max(...ys)) / 2
|
|
targetTransformRef.current = { scale, x: rect.width / 2 - cx * scale, y: rect.height * 0.42 - cy * scale }
|
|
},
|
|
getScale: () => transformRef.current.scale,
|
|
moveSibling,
|
|
getSiblingPlace,
|
|
MIN_SCALE,
|
|
MAX_SCALE,
|
|
}), [getAnimatedPos, moveSibling, getSiblingPlace])
|
|
|
|
// Zoom util (used by pinch)
|
|
const zoomAt = useCallback((factor, center) => {
|
|
const base = targetTransformRef.current
|
|
const newScale = Math.min(MAX_SCALE, Math.max(MIN_SCALE, base.scale * factor))
|
|
const ratio = newScale / base.scale
|
|
isZooming.current = true
|
|
if (zoomTimeoutRef.current) clearTimeout(zoomTimeoutRef.current)
|
|
zoomTimeoutRef.current = setTimeout(() => { isZooming.current = false }, 220)
|
|
targetTransformRef.current = {
|
|
scale: newScale,
|
|
x: center.x - ratio * (center.x - base.x),
|
|
y: center.y - ratio * (center.y - base.y),
|
|
}
|
|
}, [isZooming, targetTransformRef, zoomTimeoutRef])
|
|
|
|
// Resize canvas to device pixel ratio. Le CSS donne au canvas toute la page (.galaxy-canvas) ; on lit sa taille
|
|
// réelle. Avec window.innerHeight, Safari sur iPad gardait une hauteur prise clavier ou barre ouverte, sans
|
|
// événement resize ensuite : l'arbre s'arrêtait net au-dessus du bas de l'écran.
|
|
useEffect(() => {
|
|
const canvas = canvasRef.current
|
|
if (!canvas) return undefined
|
|
const resize = () => {
|
|
const cssW = canvas.clientWidth || window.innerWidth
|
|
const cssH = canvas.clientHeight || window.innerHeight
|
|
const dpr = Math.min(window.devicePixelRatio || 1, 2)
|
|
const w = Math.floor(cssW * dpr), h = Math.floor(cssH * dpr)
|
|
if (canvas.width === w && canvas.height === h && dprRef.current === dpr) return
|
|
dprRef.current = dpr
|
|
canvas.width = w
|
|
canvas.height = h
|
|
needsRedrawRef.current = true
|
|
}
|
|
resize()
|
|
const observer = typeof ResizeObserver === 'undefined' ? null : new ResizeObserver(resize)
|
|
observer?.observe(canvas)
|
|
window.addEventListener('resize', resize)
|
|
return () => {
|
|
observer?.disconnect()
|
|
window.removeEventListener('resize', resize)
|
|
}
|
|
}, [])
|
|
|
|
// Liste arrivée : l'arbre affiché (famille de départ) ne change pas, ses pastilles prennent le nom et le compte de
|
|
// l'onglet où elles mènent
|
|
const applyTabs = useCallback((req, list) => {
|
|
if (tabsRequestRef.current !== req) return
|
|
tabsRequestRef.current = null
|
|
tabsCacheRef.current = { rev: req.rev, start: req.start, tabs: list }
|
|
setTabs(list)
|
|
for (const n of layoutDataRef.current?.children || []) {
|
|
const target = n._familyTab && list.find((tb) => tb.key === n._familyTab.tabKey)
|
|
if (target) n._familyTab = { ...n._familyTab, label: target.label, count: target.count }
|
|
}
|
|
needsRedrawRef.current = true
|
|
}, [])
|
|
|
|
// Lance le calcul de la liste dans un worker ; faux si le navigateur ne le permet pas (on calcule alors sur place)
|
|
const requestTabs = useCallback((rev, start, referenceId) => {
|
|
cancelTabsRequest()
|
|
if (typeof Worker === 'undefined') return false
|
|
let worker
|
|
try {
|
|
worker = new Worker(new URL('./galaxy/familyTabsWorker.js', import.meta.url), { type: 'module' })
|
|
worker.postMessage({ graph: { persons: graphPersons, unions: graphUnions, filiations: graphFiliations }, referenceId })
|
|
} catch {
|
|
worker?.terminate()
|
|
return false
|
|
}
|
|
const req = { rev, start, worker }
|
|
tabsRequestRef.current = req
|
|
// Échec du worker : la liste est calculée sur place, sans toucher aux couples de l'arbre affiché
|
|
const fallback = () => {
|
|
if (tabsRequestRef.current !== req) return
|
|
const meta = coupleBarMeta
|
|
const list = familyTabsOf(null, referenceId)
|
|
restoreCoupleBarMeta(meta)
|
|
applyTabs(req, list)
|
|
}
|
|
worker.onmessage = ({ data }) => {
|
|
worker.terminate()
|
|
if (data.error) fallback()
|
|
else applyTabs(req, data.tabs)
|
|
}
|
|
worker.onerror = () => { worker.terminate(); fallback() }
|
|
return true
|
|
}, [cancelTabsRequest, applyTabs])
|
|
|
|
// Layout
|
|
useEffect(() => {
|
|
// Onglets : la liste des familles, une fois par version du graphe et par personne de départ. Calculée
|
|
// avant l'arbre affiché, parce que chaque calcul de placement remplit les couples du module (coupleBarMeta)
|
|
const start = startRefRef.current != null ? String(startRefRef.current) : null
|
|
const cache = tabsCacheRef.current
|
|
let freshTabs = null
|
|
// Liste en attente du worker : l'arbre affiché est celui de la famille de départ
|
|
let tabsPending = false
|
|
if (familyTabs && (cache.rev !== graphRevision || cache.start !== start)) {
|
|
const pending = tabsRequestRef.current
|
|
// Dans un onglet d'une autre famille, ou à l'arrivée par le lien d'un onglet, l'arbre affiché dépend de la
|
|
// liste : elle est calculée sur place
|
|
const inOtherTab = Boolean(cache.tabs.find((tb) => tb.key === activeKey)?.personIds)
|
|
if (!inOtherTab && pendingFamilyRef.current == null) {
|
|
tabsPending = (pending && pending.rev === graphRevision && pending.start === start) || requestTabs(graphRevision, start, startRefRef.current)
|
|
}
|
|
if (!tabsPending) {
|
|
cancelTabsRequest()
|
|
freshTabs = familyTabsOf(null, startRefRef.current)
|
|
tabsCacheRef.current = { rev: graphRevision, start, tabs: freshTabs }
|
|
setTabs(freshTabs)
|
|
}
|
|
}
|
|
if (!familyTabs) {
|
|
cancelTabsRequest()
|
|
if (tabsCacheRef.current.tabs.length) { tabsCacheRef.current = { rev: -1, start: undefined, tabs: [] }; setTabs([]) }
|
|
}
|
|
// La famille du lien : son onglet s'il existe dans ce navigateur, sinon l'arbre entier ouvert sur sa charnière
|
|
if (pendingFamilyRef.current != null && graphPersons.length) {
|
|
const key = pendingFamilyRef.current
|
|
pendingFamilyRef.current = null
|
|
if (familyTabs && tabsCacheRef.current.tabs.some((tb) => tb.key === key)) {
|
|
frameOnRef.current = null
|
|
if (key !== activeKey) { setActiveKey(key); return }
|
|
} else frameOnRef.current = key
|
|
}
|
|
const tab = familyTabs && !tabsPending ? (tabsCacheRef.current.tabs.find((tb) => tb.key === activeKey) || tabsCacheRef.current.tabs[0] || null) : null
|
|
activeTabRef.current = tab
|
|
// La personne de départ (ou la charnière de l'onglet) sert de référence aux rangées
|
|
focusPersonIdRef.current = tab ? tab.referenceId : startRefRef.current
|
|
// Dans l'onglet d'une autre famille, la personne commune (« C'est moi », sinon la personne de départ) reste
|
|
// là, reliée par sa ligne directe (Patch, 21/10 : « je veux me voir tout le temps »)
|
|
const line = tab?.personIds ? lineToFamily(selfPersonId ?? startRefRef.current ?? tabsCacheRef.current.tabs[0]?.resolvedRef, tab.personIds) : new Set()
|
|
const tabGraph = tab?.personIds ? subgraphOf(new Set([...tab.personIds, ...line])) : null
|
|
const graph = hasGhosts(ghosts)
|
|
? withGhosts(tabGraph || { persons: graphPersons, unions: graphUnions, filiations: graphFiliations }, ghosts, !tabGraph)
|
|
: tabGraph
|
|
// Annotations d'avant l'ancrage (x, y seuls) : rattachées une fois à la personne la plus proche dans le
|
|
// placement de l'onglet de départ, puis enregistrées. Calculé avant l'arbre affiché (coupleBarMeta, voir plus haut)
|
|
const legacy = annotationData.some((a) => !readAnchor(a))
|
|
const departure = legacy && graph ? computeBlockLayout(null, startRefRef.current, { familyTabs }) : null
|
|
// Famille de départ sans propositions : son placement vient d'être calculé avec la liste des onglets
|
|
const kept = !graph && tab === freshTabs?.[0] ? takeRootLayout(freshTabs, focusPersonIdRef.current) : null
|
|
const result = kept || computeBlockLayout(graph, focusPersonIdRef.current, { familyTabs })
|
|
if (legacy) {
|
|
const anchored = anchorLegacy(annotationData, layoutCenters(departure || result))
|
|
for (const ann of anchored) updateAnnotationInStore(ann.id, { style: ann.style })
|
|
if (anchored.length) onAnnotationsAnchoredRef.current?.(anchored)
|
|
}
|
|
// Les pastilles portent le nom de l'onglet où elles mènent (prénoms ajoutés aux homonymes)
|
|
for (const n of result.children) {
|
|
const target = n._familyTab && tabsCacheRef.current.tabs.find((tb) => tb.key === n._familyTab.tabKey)
|
|
if (target) n._familyTab = { ...n._familyTab, label: target.label, count: target.count }
|
|
}
|
|
for (const n of result.children) if (n._type === 'person' && line.has(n.id.replace(/^p-/, ''))) n._line = true
|
|
// Dans l'onglet d'une belle-famille, chaque charnière (conjoint marié dans la famille d'où l'on vient)
|
|
// porte le badge de retour
|
|
if (tab?.parentKey) {
|
|
const parent = tabsCacheRef.current.tabs.find((tb) => tb.key === tab.parentKey)
|
|
for (const h of (tab.hinges || [tab.referenceId])) {
|
|
const node = result.children.find((n) => n.id === `p-${h}`)
|
|
if (parent && node) node._familyTab = { anchorId: node.id, label: parent.label, count: parent.count, tabKey: parent.key, place: 'above', back: true }
|
|
}
|
|
}
|
|
|
|
const canvas = canvasRef.current
|
|
if (!canvas) return
|
|
const cssW = canvas.clientWidth || window.innerWidth
|
|
const cssH = canvas.clientHeight || window.innerHeight
|
|
|
|
let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity
|
|
result.children.forEach(n => {
|
|
minX = Math.min(minX, n.x)
|
|
minY = Math.min(minY, n.y)
|
|
maxX = Math.max(maxX, n.x + n.width)
|
|
maxY = Math.max(maxY, n.y + n.height)
|
|
})
|
|
const graphW = maxX - minX
|
|
const graphH = maxY - minY
|
|
const maxInitScale = 1.2
|
|
const padding = 80
|
|
const fitScale = Math.min(
|
|
(cssW - padding * 2) / Math.max(graphW, 1),
|
|
(cssH - padding * 2) / Math.max(graphH, 1),
|
|
maxInitScale,
|
|
)
|
|
let scale = Math.max(MIN_SCALE, fitScale)
|
|
let offsetX = (cssW - graphW * scale) / 2 - minX * scale
|
|
let offsetY = (cssH - graphH * scale) / 2 - minY * scale
|
|
|
|
// Grand arbre : vu en entier, les portraits deviennent des pastilles illisibles.
|
|
// On ouvre sur la personne de départ, à une taille où l'on reconnaît les visages.
|
|
const focusId = frameOnRef.current ?? focusPersonIdRef.current
|
|
const personNodes = result.children.filter((n) => n._type === 'person')
|
|
let focusNode = focusId != null
|
|
? personNodes.find((n) => String(n._data?.id) === String(focusId))
|
|
: null
|
|
// Sans personne de départ : la personne avec un portrait la plus proche du centre de la famille
|
|
if (!focusNode && personNodes.length > 0) {
|
|
const cx = personNodes.reduce((sum, n) => sum + n.x + n.width / 2, 0) / personNodes.length
|
|
const cy = personNodes.reduce((sum, n) => sum + n.y + n.height / 2, 0) / personNodes.length
|
|
const candidates = personNodes.some((n) => n._data?.photo) ? personNodes.filter((n) => n._data?.photo) : personNodes
|
|
focusNode = candidates.reduce((best, n) => {
|
|
const d = (n.x + n.width / 2 - cx) ** 2 + (n.y + n.height / 2 - cy) ** 2
|
|
return !best || d < best.d ? { n, d } : best
|
|
}, null)?.n || null
|
|
}
|
|
if (focusNode && fitScale < FOCUS_MIN_READABLE_SCALE) {
|
|
scale = FOCUS_SCALE
|
|
offsetX = (cssW < 768 ? (PHONE_SLIDER_BAND + cssW) / 2 : cssW / 2) - (focusNode.x + focusNode.width / 2) * scale
|
|
// Sur un écran étroit, la barre des familles couvre le haut : la personne de départ un peu plus bas. Plus de
|
|
// fiche ouverte à l'arrivée sur téléphone (#188) : 0,4 et non plus 0,56, sinon le haut de l'écran reste vide
|
|
offsetY = cssH * (cssW < 768 ? 0.4 : 0.42) - (focusNode.y + focusNode.height / 2) * scale
|
|
}
|
|
|
|
const anc = anchorRef.current
|
|
anchorRef.current = null
|
|
const ancNode = anc && personNodes.find((n) => String(n._data?.id) === anc.id)
|
|
if (ancNode) {
|
|
scale = anc.scale
|
|
offsetX = anc.sx - (ancNode.x + ancNode.width / 2) * scale
|
|
offsetY = anc.sy - (ancNode.y + ancNode.height / 2) * scale
|
|
}
|
|
|
|
const init = { x: offsetX, y: offsetY, scale }
|
|
initialTransformRef.current = init
|
|
transformRef.current = init
|
|
targetTransformRef.current = init
|
|
nodeRandomDataRef.current = generateNodeRandomData(result.children, result.edges)
|
|
|
|
// Entrée, à la première ouverture de l'arbre seulement. La caméra part serrée sur la personne de départ et
|
|
// recule jusqu'à la vue d'arrivée ; chaque personne apparaît quand elle entre dans le champ, la personne de
|
|
// départ dès la première image. On reprend la main à tout moment (le recul s'arrête au premier geste).
|
|
// Mouvements réduits : pas de recul, un fondu court. Ensuite (modification, autre onglet) : rien ne s'anime.
|
|
const nodeSchedule = new Map()
|
|
const coupleSchedule = new Map()
|
|
const edgeSchedule = new Map()
|
|
const orbitSchedule = new Map()
|
|
let maxEndMs = 0
|
|
let camera = null
|
|
const treeKey = String(graphPersons[0]?.id ?? '')
|
|
const firstOpen = treeKey !== '' && openedTreeRef.current !== treeKey
|
|
if (treeKey) openedTreeRef.current = treeKey
|
|
if (!firstOpen) {
|
|
for (const n of result.children) nodeSchedule.set(n.id, { startMs: -Infinity, duration: 1 })
|
|
} else if (prefersReducedMotion() || !focusNode) {
|
|
for (const n of result.children) nodeSchedule.set(n.id, { startMs: 0, duration: ENTRANCE_REDUCED_DURATION })
|
|
maxEndMs = ENTRANCE_REDUCED_DURATION
|
|
} else {
|
|
const fx = focusNode.x + focusNode.width / 2, fy = focusNode.y + focusNode.height / 2
|
|
const sx = fx * init.scale + init.x, sy = fy * init.scale + init.y
|
|
const at = (sc) => ({ scale: sc, x: sx - fx * sc, y: sy - fy * sc })
|
|
camera = { from: at(Math.min(MAX_SCALE, Math.max(ENTRANCE_CAMERA_FROM_SCALE, init.scale * 1.6))), to: init, durationMs: ENTRANCE_CAMERA_DURATION }
|
|
camera.last = camera.from
|
|
// Instant où le recul fait entrer la personne dans le champ (marge de 40 px), ou null si elle reste dehors
|
|
const entersAt = (n) => {
|
|
const nx = n.x + n.width / 2 - fx, ny = n.y + n.height / 2 - fy
|
|
for (let i = 0; i <= 60; i++) {
|
|
const sc = camera.from.scale + (init.scale - camera.from.scale) * easeOutQuint(i / 60)
|
|
const px = sx + nx * sc, py = sy + ny * sc
|
|
if (px > -40 && px < cssW + 40 && py > -40 && py < cssH + 40) return (i / 60) * camera.durationMs
|
|
}
|
|
return null
|
|
}
|
|
for (const n of result.children) {
|
|
const t = n === focusNode ? 0 : entersAt(n)
|
|
if (t == null) { nodeSchedule.set(n.id, { startMs: -Infinity, duration: 1 }); continue }
|
|
const startMs = t === 0 ? 0 : Math.max(0, t - 120) + Math.random() * 40
|
|
nodeSchedule.set(n.id, { startMs, duration: ENTRANCE_NODE_DURATION })
|
|
maxEndMs = Math.max(maxEndMs, startMs + ENTRANCE_NODE_DURATION)
|
|
}
|
|
transformRef.current = camera.from
|
|
targetTransformRef.current = camera.from
|
|
}
|
|
|
|
coupleBarMeta.forEach(({ elkId, p1Key, p2Key }) => {
|
|
const s1 = nodeSchedule.get(p1Key)
|
|
const s2 = nodeSchedule.get(p2Key)
|
|
if (s1 && s2) {
|
|
const startMs = Math.max(s1.startMs, s2.startMs) + ENTRANCE_NODE_DURATION * 0.5 + ENTRANCE_LINE_DELAY * 0.3
|
|
coupleSchedule.set(elkId, { startMs, duration: ENTRANCE_LINE_DURATION })
|
|
maxEndMs = Math.max(maxEndMs, startMs + ENTRANCE_LINE_DURATION)
|
|
}
|
|
})
|
|
|
|
if (result.edges) {
|
|
result.edges.forEach(edge => {
|
|
const sourceId = edge.sources[0]
|
|
const sSource = nodeSchedule.get(sourceId)
|
|
if (sSource) {
|
|
const startMs = sSource.startMs + ENTRANCE_LINE_DELAY
|
|
edgeSchedule.set(edge.id, { startMs, duration: ENTRANCE_LINE_DURATION })
|
|
maxEndMs = Math.max(maxEndMs, startMs + ENTRANCE_LINE_DURATION)
|
|
}
|
|
})
|
|
}
|
|
|
|
result.children.forEach(node => {
|
|
if (node._type !== 'person') return
|
|
const sNode = nodeSchedule.get(node.id)
|
|
if (!sNode) return
|
|
const pMedias = getPersonMedias(node._data.id)
|
|
const count = Math.min(pMedias.length, MAX_ORBIT_MEDIAS)
|
|
for (let i = 0; i < count; i++) {
|
|
const startMs = sNode.startMs + sNode.duration + ENTRANCE_ORBIT_DELAY + i * ENTRANCE_ORBIT_STAGGER
|
|
orbitSchedule.set(`${node.id}:${i}`, { startMs, duration: ENTRANCE_ORBIT_DURATION })
|
|
maxEndMs = Math.max(maxEndMs, startMs + ENTRANCE_ORBIT_DURATION)
|
|
}
|
|
})
|
|
|
|
entranceRef.current = {
|
|
camera,
|
|
startTime: -1,
|
|
nodeSchedule, coupleSchedule, edgeSchedule, orbitSchedule,
|
|
totalDurationMs: maxEndMs,
|
|
finished: false,
|
|
}
|
|
|
|
offsetsRef.current = new Map()
|
|
reorderRef.current = null
|
|
layoutDataRef.current = result
|
|
needsRedrawRef.current = true
|
|
setLayoutReady(true)
|
|
if (pendingFocusRef.current) {
|
|
const id = pendingFocusRef.current
|
|
pendingFocusRef.current = null
|
|
requestAnimationFrame(() => zoomApiRef?.current?.focusPerson?.(id))
|
|
}
|
|
if (pendingFrameRef.current) {
|
|
const ids = pendingFrameRef.current
|
|
pendingFrameRef.current = null
|
|
requestAnimationFrame(() => zoomApiRef?.current?.focusPersons?.(ids))
|
|
}
|
|
}, [graphRevision, activeKey, familyTabs, selfPersonId, ghosts, requestTabs, cancelTabsRequest])
|
|
|
|
// Onglet ouvert, remonté pour l'adresse de la page et le lien de partage ; null pour la famille de départ
|
|
useEffect(() => {
|
|
if (pendingFamilyRef.current != null) return
|
|
const open = familyTabs && tabs.length > 1 ? tabs.find((tb) => tb.key === activeKey) : null
|
|
onFamilyChangeRef.current?.(open && open !== tabs[0] ? { key: open.key, label: open.label } : null)
|
|
}, [activeKey, tabs, familyTabs])
|
|
|
|
// Sync selectedPersonId
|
|
useEffect(() => {
|
|
selectedPersonIdRef.current = selectedPersonId
|
|
}, [selectedPersonId])
|
|
|
|
// Sync searchHighlightIds
|
|
const searchHighlightIdsRef = useRef(searchHighlightIds)
|
|
useEffect(() => {
|
|
searchHighlightIdsRef.current = searchHighlightIds
|
|
searchHighlightSetRef.current = new Set(searchHighlightIds.map(id => `p-${id}`))
|
|
}, [searchHighlightIds])
|
|
|
|
// Recalculer les proches immédiats
|
|
useEffect(() => {
|
|
const relatives = new Set()
|
|
if (selectedPersonId != null) {
|
|
getParents(selectedPersonId).forEach(p => relatives.add(`p-${p.id}`))
|
|
getChildren(selectedPersonId).forEach(c => relatives.add(`p-${c.id}`))
|
|
getPersonUnions(selectedPersonId).forEach(u => {
|
|
const spouseId = u.partner1Id === selectedPersonId ? u.partner2Id : u.partner1Id
|
|
relatives.add(`p-${spouseId}`)
|
|
})
|
|
}
|
|
immediateRelativesRef.current = relatives
|
|
}, [selectedPersonId])
|
|
|
|
// Boucle d'animation + rendu canvas
|
|
useEffect(() => {
|
|
if (!layoutReady) return
|
|
|
|
let rafId
|
|
|
|
const animate = (timestamp) => {
|
|
let dirty = needsRedrawRef.current
|
|
needsRedrawRef.current = false
|
|
|
|
const entrance = entranceRef.current
|
|
if (entrance && entrance.startTime < 0) entrance.startTime = timestamp
|
|
const elapsed = entrance ? timestamp - entrance.startTime : Infinity
|
|
const entranceActive = entrance && !entrance.finished
|
|
if (entranceActive && elapsed > entrance.totalDurationMs + 100) entrance.finished = true
|
|
// Pendant l'entrée et le fondu des annotations qui la suit, on redessine chaque frame
|
|
if (entrance && elapsed < entrance.totalDurationMs + 500) dirty = true
|
|
|
|
// Recul de la caméra à l'ouverture, abandonné dès qu'on déplace ou zoome soi-même l'arbre
|
|
const cam = entrance?.camera
|
|
if (cam) {
|
|
if (targetTransformRef.current !== cam.last) entrance.camera = null
|
|
else {
|
|
const k = easeOutQuint(Math.min(1, Math.max(0, elapsed / cam.durationMs)))
|
|
const t = {
|
|
scale: cam.from.scale + (cam.to.scale - cam.from.scale) * k,
|
|
x: cam.from.x + (cam.to.x - cam.from.x) * k,
|
|
y: cam.from.y + (cam.to.y - cam.from.y) * k,
|
|
}
|
|
transformRef.current = t
|
|
targetTransformRef.current = t
|
|
cam.last = t
|
|
dirty = true
|
|
if (k >= 1) entrance.camera = null
|
|
}
|
|
}
|
|
// Lissage du transform
|
|
const target = targetTransformRef.current
|
|
const prev = transformRef.current
|
|
const easing = isDragging.current ? 0.24 : isZooming.current ? 0.08 : 0.14
|
|
const next = {
|
|
x: approach(prev.x, target.x, easing, 0.05),
|
|
y: approach(prev.y, target.y, easing, 0.05),
|
|
scale: approach(prev.scale, target.scale, easing, 1e-4),
|
|
}
|
|
if (next.x !== prev.x || next.y !== prev.y || next.scale !== prev.scale) dirty = true
|
|
transformRef.current = next
|
|
|
|
// Réordonnancement : la personne tenue suit le pointeur, les autres glissent vers leur place
|
|
const dt = lastFrameRef.current ? Math.min(0.034, (timestamp - lastFrameRef.current) / 1000) : 1 / 60
|
|
lastFrameRef.current = timestamp
|
|
const drag = reorderRef.current?.phase === 'dragging' ? reorderRef.current : null
|
|
if (offsetsRef.current.size > 0) {
|
|
for (const [id, state] of offsetsRef.current) {
|
|
if (drag && id === drag.nodeId) continue
|
|
const next = springStep(state, dt, state.spring)
|
|
if (isSettled(next)) offsetsRef.current.delete(id)
|
|
else offsetsRef.current.set(id, { ...next, spring: state.spring })
|
|
}
|
|
dirty = true
|
|
}
|
|
if (drag && layoutDataRef.current) {
|
|
const held = layoutDataRef.current.children.find((n) => n.id === drag.nodeId)
|
|
if (held) offsetsRef.current.set(drag.nodeId, { x: drag.targetCenter - centerX(held), v: 0, spring: DROP_SPRING })
|
|
dirty = true
|
|
}
|
|
for (const [id, value] of liftScalesRef.current) {
|
|
const target = drag && id === drag.nodeId ? 1 : 0
|
|
const next = approach(value, target, 0.28, 0.002)
|
|
if (next === 0 && target === 0) liftScalesRef.current.delete(id)
|
|
else liftScalesRef.current.set(id, next)
|
|
if (next !== value) dirty = true
|
|
}
|
|
if (drag && !liftScalesRef.current.has(drag.nodeId)) { liftScalesRef.current.set(drag.nodeId, 0); dirty = true }
|
|
|
|
const layoutData = layoutDataRef.current
|
|
const canvas = canvasRef.current
|
|
if (!layoutData || !canvas) { rafId = requestAnimationFrame(animate); return }
|
|
const { x, y, scale } = transformRef.current
|
|
|
|
// Lissage hover states
|
|
const hoverEasing = 0.12
|
|
layoutData.children.forEach(node => {
|
|
if (node._type !== 'person') return
|
|
const targetScale = hoveredNodeId.current === node.id ? 1 : 0
|
|
const prevScale = hoverScales.current.get(node.id) || 0
|
|
const newScale = approach(prevScale, targetScale, hoverEasing)
|
|
if (newScale !== prevScale) { dirty = true; hoverScales.current.set(node.id, newScale) }
|
|
const rd = nodeRandomDataRef.current.get(node.id)
|
|
const pMedias = getPersonMedias(node._data.id)
|
|
const orbitSlots = rd?.orbitSlots || []
|
|
const orbitCount = Math.min(pMedias.length, MAX_ORBIT_MEDIAS)
|
|
for (let i = 0; i < orbitCount; i++) {
|
|
const key = `${node.id}:${i}`
|
|
const slot = orbitSlots[i]
|
|
if (!slot) continue
|
|
const isHovered = hoveredMediaKey.current === key
|
|
const prevMh = mediaHoverState.current.get(key) || { scale: 0, dx: 0, dy: 0 }
|
|
const dirX = Math.cos(slot.angle)
|
|
const dirY = Math.sin(slot.angle)
|
|
const targetS = isHovered ? 1 : 0
|
|
const targetDx = isHovered ? dirX * 6 : 0
|
|
const targetDy = isHovered ? dirY * 6 : 0
|
|
const nextMh = {
|
|
scale: approach(prevMh.scale, targetS, hoverEasing),
|
|
dx: approach(prevMh.dx, targetDx, hoverEasing),
|
|
dy: approach(prevMh.dy, targetDy, hoverEasing),
|
|
}
|
|
if (nextMh.scale !== prevMh.scale || nextMh.dx !== prevMh.dx || nextMh.dy !== prevMh.dy) {
|
|
dirty = true
|
|
mediaHoverState.current.set(key, nextMh)
|
|
}
|
|
}
|
|
})
|
|
|
|
// Lerp annotation drag lift (0 → 1)
|
|
const dragTarget = annotationHandlers?.isDragging ? 1 : 0
|
|
const prevLift = dragLiftProgress.current
|
|
dragLiftProgress.current = approach(prevLift, dragTarget, 0.15, 0.005)
|
|
if (dragLiftProgress.current !== prevLift) dirty = true
|
|
// Outil d'annotation actif : l'aperçu suit la souris, on redessine
|
|
if (annotationHandlers?.activeTool || annotationHandlers?.isDragging) dirty = true
|
|
if (annotationData !== lastAnnotationDataRef.current) { lastAnnotationDataRef.current = annotationData; dirty = true }
|
|
|
|
// Lissage glow sélection
|
|
const selectedElkId = selectedPersonIdRef.current != null ? `p-${selectedPersonIdRef.current}` : null
|
|
const selectionEasing = 0.08
|
|
layoutData.children.forEach(node => {
|
|
if (node._type !== 'person') return
|
|
let targetGlow = 0
|
|
if (selectedElkId) {
|
|
if (node.id === selectedElkId) targetGlow = 1.0
|
|
else if (immediateRelativesRef.current.has(node.id)) targetGlow = 0.6
|
|
}
|
|
const prevGlow = selectedGlowScales.current.get(node.id) || 0
|
|
const nextGlow = approach(prevGlow, targetGlow, selectionEasing)
|
|
if (nextGlow !== prevGlow) { dirty = true; selectedGlowScales.current.set(node.id, nextGlow) }
|
|
})
|
|
|
|
// Animation search highlight glow
|
|
const searchEasing = 0.12
|
|
const searchHighlightSet = searchHighlightSetRef.current
|
|
layoutData.children.forEach(node => {
|
|
if (node._type !== 'person') return
|
|
const targetSearchGlow = searchHighlightSet.has(node.id) ? 1.2 : 0
|
|
const prevSearchGlow = searchGlowScales.current.get(node.id) || 0
|
|
const nextSearchGlow = approach(prevSearchGlow, targetSearchGlow, searchEasing)
|
|
if (nextSearchGlow !== prevSearchGlow) { dirty = true; searchGlowScales.current.set(node.id, nextSearchGlow) }
|
|
})
|
|
|
|
// Chemin BFS
|
|
const currentHovered = hoveredNodeId.current
|
|
const pathInputChanged = lastPathInputRef.current.selected !== selectedElkId ||
|
|
lastPathInputRef.current.hovered !== currentHovered
|
|
if (pathInputChanged) {
|
|
dirty = true
|
|
lastPathInputRef.current = { selected: selectedElkId, hovered: currentHovered }
|
|
if (selectedElkId && currentHovered && currentHovered !== selectedElkId && currentHovered.startsWith('p-')) {
|
|
const result = findPathBFS(selectedElkId, currentHovered, layoutData, graphPersons)
|
|
pathNodesRef.current = result ? result.nodePath : []
|
|
pathEdgesRef.current = result ? result.edgePath : []
|
|
pathLabelRef.current = result ? result.label : ''
|
|
pathStartTime.current = timestamp
|
|
} else {
|
|
pathNodesRef.current = []
|
|
pathEdgesRef.current = []
|
|
pathLabelRef.current = ''
|
|
pathStartTime.current = -1
|
|
}
|
|
}
|
|
|
|
// Lissage highlight chemin
|
|
const PATH_EDGE_STAGGER = 120
|
|
const PATH_EDGE_DURATION = 300
|
|
const pathElapsed = pathStartTime.current > 0 ? timestamp - pathStartTime.current : -1
|
|
const pathEasing = 0.12
|
|
|
|
for (let i = 0; i < pathEdgesRef.current.length; i++) {
|
|
const e = pathEdgesRef.current[i]
|
|
const staggeredTarget = pathElapsed >= 0
|
|
? easeOutCubic(Math.min(1, Math.max(0, (pathElapsed - i * PATH_EDGE_STAGGER) / PATH_EDGE_DURATION)))
|
|
: 0
|
|
if (pathProgressRef.current.get(e.id) !== staggeredTarget) { dirty = true; pathProgressRef.current.set(e.id, staggeredTarget) }
|
|
}
|
|
for (let i = 0; i < pathNodesRef.current.length; i++) {
|
|
const n = pathNodesRef.current[i]
|
|
const edgeIdx = Math.max(0, i - 1)
|
|
const staggeredTarget = pathElapsed >= 0
|
|
? easeOutCubic(Math.min(1, Math.max(0, (pathElapsed - edgeIdx * PATH_EDGE_STAGGER) / PATH_EDGE_DURATION)))
|
|
: 0
|
|
if (pathProgressRef.current.get(n) !== staggeredTarget) { dirty = true; pathProgressRef.current.set(n, staggeredTarget) }
|
|
}
|
|
|
|
// Au repos, rien à éteindre : pas d'ensembles reconstruits à chaque frame
|
|
if (pathProgressRef.current.size > 0) {
|
|
const activePathEdges = new Set(pathEdgesRef.current.map(e => e.id))
|
|
const activePathNodes = new Set(pathNodesRef.current)
|
|
for (const [key, val] of pathProgressRef.current) {
|
|
if (!activePathEdges.has(key) && !activePathNodes.has(key)) {
|
|
dirty = true
|
|
const next = val + (0 - val) * pathEasing
|
|
if (Math.abs(next) < 0.001) pathProgressRef.current.delete(key)
|
|
else pathProgressRef.current.set(key, next)
|
|
}
|
|
}
|
|
}
|
|
|
|
const lastEdgeStart = (pathEdgesRef.current.length - 1) * PATH_EDGE_STAGGER
|
|
const targetLabelAlpha = pathElapsed >= 0 && pathElapsed > lastEdgeStart ? 1 : 0
|
|
const prevLabelAlpha = pathLabelAlpha.current
|
|
pathLabelAlpha.current = approach(prevLabelAlpha, targetLabelAlpha, pathEasing)
|
|
if (pathLabelAlpha.current !== prevLabelAlpha) dirty = true
|
|
|
|
// Mise à jour de l'overlay HTML (seulement quand la valeur change)
|
|
const newDisplayLabel = pathLabelAlpha.current > 0.05 ? pathLabelRef.current : ''
|
|
if (newDisplayLabel !== displayLabelRef.current) {
|
|
displayLabelRef.current = newDisplayLabel
|
|
setDisplayLabel(newDisplayLabel)
|
|
}
|
|
|
|
// Rien n'a changé : on ne redessine pas
|
|
if (!dirty) { rafId = requestAnimationFrame(animate); return }
|
|
|
|
// Positions animées, calculées seulement quand on redessine
|
|
const posMap = new Map()
|
|
layoutData.children.forEach(node => {
|
|
posMap.set(node.id, getAnimatedPos(node, timestamp))
|
|
})
|
|
|
|
const nodeMap = new Map()
|
|
layoutData.children.forEach(n => nodeMap.set(n.id, n))
|
|
|
|
// === RENDU ===
|
|
const ctx = canvas.getContext('2d')
|
|
ctx.setTransform(dprRef.current, 0, 0, dprRef.current, 0, 0)
|
|
drawBackground(ctx, canvas)
|
|
ctx.save()
|
|
ctx.translate(x, y)
|
|
ctx.scale(scale, scale)
|
|
|
|
// Fenêtre visible en coordonnées monde (culling + niveau de détail dans les renderers)
|
|
const cssW = canvas.width / dprRef.current
|
|
const cssH = canvas.height / dprRef.current
|
|
const view = { x0: -x / scale, y0: -y / scale, x1: (cssW - x) / scale, y1: (cssH - y) / scale, scale }
|
|
drawCoupleLinks(ctx, coupleBarMeta, posMap, nodeMap, nodeRandomDataRef.current, entrance, entranceActive, elapsed, view)
|
|
drawFiliations(ctx, layoutData.edges, posMap, nodeMap, nodeRandomDataRef.current, entrance, entranceActive, elapsed, view)
|
|
drawPathHighlight(ctx, {
|
|
pathEdgesRef: pathEdgesRef.current,
|
|
pathNodesRef: pathNodesRef.current,
|
|
pathLabelAlpha: pathLabelAlpha.current,
|
|
pathProgressRef: pathProgressRef.current,
|
|
selectedElkId,
|
|
hoveredNodeId: hoveredNodeId.current,
|
|
coupleBarMeta,
|
|
posMap, nodeMap,
|
|
nodeRandomData: nodeRandomDataRef.current,
|
|
layoutData,
|
|
})
|
|
drawNodes(ctx, layoutData, posMap, entrance, entranceActive, elapsed, {
|
|
nodeRandomData: nodeRandomDataRef.current,
|
|
imageCache: imageCache.current,
|
|
hoverScales: hoverScales.current,
|
|
selectedGlowScales: selectedGlowScales.current,
|
|
searchGlowScales: searchGlowScales.current,
|
|
mediaHoverState: mediaHoverState.current,
|
|
entrance, entranceActive, elapsed,
|
|
view,
|
|
liftScales: liftScalesRef.current,
|
|
ghostPatches: ghostsRef.current?.patches || null,
|
|
fullNames: fullNamesRef.current,
|
|
})
|
|
drawRenvoiPills(ctx)
|
|
// Annotations dessinées APRES les noeuds pour que stickers/texte soient au-dessus.
|
|
// Chacune suit le portrait de sa personne dans le placement affiché, absente si la personne n'y est pas.
|
|
// Les centres et les positions servent aussi à poser, toucher et déplacer (useAnnotations)
|
|
// Un texte rouvert pour être modifié n'est pas dessiné sous sa saisie (editingId, posé par useAnnotations)
|
|
const annotationCenters = layoutCenters(layoutData, offsetsRef.current)
|
|
const editingId = annotationViewRef?.current?.editingId ?? null
|
|
const anchoredAnnotations = placeAnnotations(annotationData, annotationCenters)
|
|
if (annotationViewRef) annotationViewRef.current = { editingId, centers: annotationCenters, shown: anchoredAnnotations }
|
|
|
|
// Afficher les annotations en dernier, après l'animation d'entrée
|
|
const stickerPreview = annotationHandlers?.activeTool === 'sticker' && annotationHandlers?.selectedSticker
|
|
? { emoji: annotationHandlers.selectedSticker, x: mouseWorldPos.current.x, y: mouseWorldPos.current.y, fontSize: 40 }
|
|
: null
|
|
const draggingAnnotationId = annotationHandlers?.isDragging ? annotationHandlers.selectedAnnotationId : null
|
|
const entranceAlpha = !entranceActive ? 1 : Math.min(1, Math.max(0, (elapsed - entrance.totalDurationMs) / 300))
|
|
if (entranceAlpha > 0) {
|
|
drawAnnotations(
|
|
ctx,
|
|
[
|
|
...(editingId ? anchoredAnnotations.filter((a) => a.id !== editingId) : anchoredAnnotations),
|
|
// Annotations proposées : dessinées, jamais touchables (hors de `shown`)
|
|
...placeAnnotations(ghostsRef.current?.annotations || [], annotationCenters),
|
|
],
|
|
annotationHandlers?.selectedAnnotationId ?? null,
|
|
annotationHandlers?.drawingPathRef?.current ?? null,
|
|
stickerPreview,
|
|
draggingAnnotationId,
|
|
dragLiftProgress.current,
|
|
entranceAlpha,
|
|
imageCache.current,
|
|
)
|
|
}
|
|
ctx.restore()
|
|
|
|
rafId = requestAnimationFrame(animate)
|
|
}
|
|
|
|
rafId = requestAnimationFrame(animate)
|
|
return () => {
|
|
cancelAnimationFrame(rafId)
|
|
if (zoomTimeoutRef.current) clearTimeout(zoomTimeoutRef.current)
|
|
}
|
|
}, [layoutReady, getAnimatedPos, isDragging, isZooming, zoomTimeoutRef, imageCache])
|
|
|
|
// Prevent default wheel
|
|
useEffect(() => {
|
|
const canvas = canvasRef.current
|
|
if (!canvas) return
|
|
const prevent = (e) => e.preventDefault()
|
|
canvas.addEventListener('wheel', prevent, { passive: false })
|
|
return () => canvas.removeEventListener('wheel', prevent)
|
|
}, [])
|
|
|
|
return (
|
|
<>
|
|
<canvas
|
|
ref={canvasRef}
|
|
className="galaxy-canvas"
|
|
style={{ touchAction: 'none' }}
|
|
onMouseDown={(e) => {
|
|
if (e.button === 0 && beginReorderPress(e.clientX, e.clientY, 'mouse')) { hasDragged.current = false; return }
|
|
handleMouseDown(e)
|
|
}}
|
|
onMouseMove={(e) => {
|
|
needsRedrawRef.current = true
|
|
const press = reorderRef.current
|
|
if (press?.phase === 'dragging') return
|
|
if (press?.phase === 'pressing' && press.pointer === 'mouse') {
|
|
if (Math.abs(e.clientX - press.startX) > REORDER_MOUSE_THRESHOLD || Math.abs(e.clientY - press.startY) > REORDER_MOUSE_THRESHOLD) {
|
|
startReorder(press.startX)
|
|
updateReorder(e.clientX)
|
|
}
|
|
return
|
|
}
|
|
handleMouseMove(e)
|
|
// En mode édition, une personne réordonnable se saisit
|
|
if (canvasRef.current && hoveredNodeId.current && reorderEnabledRef.current && getSiblingGroups().has(hoveredNodeId.current)) {
|
|
canvasRef.current.style.cursor = 'grab'
|
|
}
|
|
}}
|
|
onMouseUp={(e) => {
|
|
const press = reorderRef.current
|
|
if (press?.phase === 'pressing') reorderRef.current = null
|
|
if (press?.phase === 'dragging') return
|
|
handleMouseUp(e)
|
|
}}
|
|
onMouseLeave={(e) => { needsRedrawRef.current = true; if (reorderRef.current?.phase !== 'dragging') handleMouseLeave(e) }}
|
|
onWheel={handleWheel}
|
|
onTouchStart={(e) => {
|
|
if (e.touches.length === 1) {
|
|
const t = e.touches[0]
|
|
// Appui long sur une personne réordonnable ; d'ici là, le doigt fait défiler l'arbre comme d'habitude
|
|
beginReorderPress(t.clientX, t.clientY, 'touch')
|
|
handleMouseDown({ clientX: t.clientX, clientY: t.clientY, preventDefault: () => e.preventDefault() })
|
|
} else if (e.touches.length === 2) {
|
|
e.preventDefault()
|
|
// Un deuxième doigt annule le glisser d'une personne (retour à sa place, rien n'est enregistré)
|
|
if (reorderRef.current) endReorder(false)
|
|
// Stop any ongoing single-finger pan before starting pinch
|
|
handleMouseUp()
|
|
const [a, b] = e.touches
|
|
const dx = a.clientX - b.clientX
|
|
const dy = a.clientY - b.clientY
|
|
const dist = Math.hypot(dx, dy)
|
|
const center = { x: (a.clientX + b.clientX) / 2, y: (a.clientY + b.clientY) / 2 }
|
|
pinchRef.current = { dist, center }
|
|
}
|
|
}}
|
|
onTouchMove={(e) => {
|
|
needsRedrawRef.current = true
|
|
if (e.touches.length === 1) {
|
|
const t = e.touches[0]
|
|
const press = reorderRef.current
|
|
if (press?.phase === 'dragging') { updateReorder(t.clientX); return }
|
|
if (press?.phase === 'pressing') {
|
|
press.lastX = t.clientX
|
|
if (Math.hypot(t.clientX - press.startX, t.clientY - press.startY) > REORDER_TOUCH_SLOP) endReorder(false)
|
|
}
|
|
handleMouseMove({ clientX: t.clientX, clientY: t.clientY, preventDefault: () => e.preventDefault() })
|
|
} else if (e.touches.length === 2) {
|
|
e.preventDefault()
|
|
const [a, b] = e.touches
|
|
const dx = a.clientX - b.clientX
|
|
const dy = a.clientY - b.clientY
|
|
const dist = Math.hypot(dx, dy)
|
|
const center = { x: (a.clientX + b.clientX) / 2, y: (a.clientY + b.clientY) / 2 }
|
|
if (pinchRef.current) {
|
|
const factor = dist / pinchRef.current.dist
|
|
zoomAt(factor, center)
|
|
pinchRef.current = { dist, center }
|
|
} else {
|
|
pinchRef.current = { dist, center }
|
|
}
|
|
}
|
|
}}
|
|
onTouchEnd={(e) => {
|
|
if (reorderRef.current && e.touches.length === 0) {
|
|
const wasDragging = reorderRef.current.phase === 'dragging'
|
|
endReorder(true)
|
|
if (wasDragging) { handleMouseUp(); return }
|
|
}
|
|
pinchRef.current = null
|
|
if (e.touches.length === 1) {
|
|
// One finger remains after pinch: restart single-finger pan with it
|
|
// and mark hasDragged=true so the lift doesn't fire an accidental click
|
|
const t = e.touches[0]
|
|
handleMouseUp()
|
|
handleMouseDown({ clientX: t.clientX, clientY: t.clientY, preventDefault: () => e.preventDefault() })
|
|
hasDragged.current = true
|
|
} else {
|
|
handleMouseUp()
|
|
}
|
|
}}
|
|
onTouchCancel={() => {
|
|
// System interruption (notification, keyboard, etc.) — reset all touch state
|
|
if (reorderRef.current) endReorder(false)
|
|
pinchRef.current = null
|
|
handleMouseUp()
|
|
}}
|
|
onClick={handleClick}
|
|
/>
|
|
{displayLabel && (
|
|
<div className="path-label-overlay">{displayLabel}</div>
|
|
)}
|
|
{familyTabs && tabs.length > 1 && (
|
|
<nav ref={tabsBarRef} onScroll={updateTabsEdges} className={`family-tabs${annotationHandlers ? ' family-tabs--lowered' : ''}${tabsEdges}`} aria-label={tr('Familles')}>
|
|
{barTabs(tabs, activeKey).map(({ tb, gap, trait }) => {
|
|
const active = tb.key === (tabs.some((x) => x.key === activeKey) ? activeKey : tabs[0].key)
|
|
return (
|
|
<button
|
|
key={tb.key}
|
|
type="button"
|
|
style={gap ? { marginLeft: gap } : undefined}
|
|
className={`family-tab${active ? ' is-active' : ''}${trait ? ` family-tab--suite family-tab--trait-${trait}` : ''}`}
|
|
aria-current={active ? 'page' : undefined}
|
|
onClick={() => chooseTab(tb.key)}
|
|
onMouseEnter={() => { if (!active) hoverTab(tb.key) }}
|
|
onMouseLeave={leaveTab}
|
|
onFocus={() => { if (!active) hoverTab(tb.key) }}
|
|
onBlur={leaveTab}
|
|
>
|
|
<span className="family-tab-name">{tb.label ? tr('Famille {name}', { name: surnameLabel(tb.label) }) : tr('Famille')}</span>
|
|
<span className="family-tab-count" title={tr('{n} personnes', { n: tb.count })}>{tb.count}</span>
|
|
</button>
|
|
)
|
|
})}
|
|
</nav>
|
|
)}
|
|
</>
|
|
)
|
|
}
|
|
|
|
export default memo(Galaxy)
|