tree e4e7d296ade11af6543cb8df6372c4a0f5405f5a
parent 68a3e3566c86f06ca870e404fec75b94dba0daa8
author Marc Kupietz <kupietz@ids-mannheim.de> 1784296354 +0200
committer Marc Kupietz <kupietz@ids-mannheim.de> 1784296660 +0200

Fix bottom-left logo clipping and Leibniz SVG viewBoxes

Three related defects conspired to clip the Leibniz Association logo at
the poster bottom, depending on viewport size and info-column width:

- #info-column used `bottom: 7vH` in print, but vh resolves against the
  headless-Chrome viewport, not the page, so the offset was arbitrary.
  Use a physical 25mm instead.
- The title row's margin-top collapsed through .poster_wrap, pushing the
  wrap ~6% below the page bottom, so bottom-anchored children ended up in
  the zone the @page bottom margin cuts off. `display: flow-root` on the
  wrap stops the collapse and pins it to the page.
- Both inline Leibniz logos declared `viewBox="0 0 ... 120"` while their
  drawings actually span y=89..388, so part of the artwork (notably the
  "Leibniz Association" caption) could fall outside the rendered area at
  certain element widths. Set the viewBoxes to the true drawing extents
  (measured with inkscape --query).

Verified with the CMC2026 and DeLiKo@DNB posters: logo complete on both,
layouts otherwise unchanged.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Change-Id: Id0d871069d5a3576231313cb5d4acb20495b0c18
