Antes de começar, uma pergunta semelhante (minha) existe, eu gostaria que essa fosse deletada, já que eu não expliquei bem o meu ponto lá, mas não esta. Obrigado.

Primeiro de tudo, eu não tenho código, este é apenas um conceito que não consigo descobrir. Mas é interessante (pelo menos para mim).

Todos vocês sabem como o MSWord funciona. Você escreve coisas. Então, quando você preencher uma página, ela criará uma nova página e começará a escrever nessa página. Se você colar mais algum texto na primeira página, tudo será empurrado para baixo. Se você excluir um grande bloco de texto em uma página, ele absorverá parte do texto da página anterior. Se você está lidando com, por exemplo fotos e você tem um em cima de uma página, reduzindo o tamanho da minha causa para ser sugado para a página anterior, se houver espaço suficiente para a versão reduzida da imagem.

Agora que você está pensando dessa maneira, quero transferir esse conceito para o Java Swing. As páginas são JPanels, e imagens e pedaços (ou linhas) de texto são JPanels ajustados na página JPanel.

Eu vim para cima (ok, eu menti, eu tenho algum código, mas é uma bagunça e não funciona mesmo assim) com um método usando um Filler, que não funciona em todos os casos. Se você quer saber por que, leia entre as duas linhas, caso contrário, pule-a.

Assim, a estrutura em si é fácil de replicar, mas a manutenção é uma dor no pescoço. Você vê, existem dois tipos principais de eventos que podem ocorrer:

a) height of the page content has increased
b) height of the page content has decreased

Usando um Filler como o último componente de uma página e tendo um componentAdapter (componentResized) anexado a ele, você pode monitorar essas alterações.

Essas mudanças podem ser divididas em:

a) element is added/removed to/from page
b) height of the element has increased/decreased 

Levando esses eventos em consideração muitas coisas podem acontecer. Ignorando os casos simples, veja este exemplo:

Page 1:
{element 1
blabla
blabla}
{element 2
blabla}
{element 3}
{element 4
blabla
blabla
blabla
blabla}
{free space
---
---
---}

/

Page 2:
{element 1
blabla
blabla
blabla
blabla}
{element 2
blabla
blabla
blabla
blabla}
{element 3}
{element 4
blabla
blabla
blabla}

/

Page 3:
{element 1}
{element 2}
{element 3}
{element 4}
{element 5}
{free space
---
---
---
---
---
---
---
---
---}

Cada página tem uma altura de 15 linhas. Veja agora o que acontece se você reduzir a altura do elemento 1 da segunda página em uma linha. Ela ficará com 4 linhas de altura, ajustando-se à página anterior, sendo sugada. Isso criará 5 (1 linha excluída + 4 linhas sugadas) linhas de espaço livre na segunda página. Isso vai sugar todos os cinco elementos da terceira página e deixar a terceira página em branco (que agora deve ser excluída).

A razão pela qual isso não funcionaria é que, após a exclusão, um ouvinte é acionado para a segunda página e precisa empurrar o elemento superior para cima e sugar os elementos da página anterior. Como tudo é feito em um ouvinte, tenho que esperar que ele seja executado para registrar a alteração visual no meu programa. Desde que tem que mudar duas coisas em uma página, trata-se de algum tipo de caos ouvinte. A altura da página é reduzida duas vezes, mas é registrada apenas uma vez e, no final, posso mover-me totalmente apenas pela parte superior ou pela parte inferior, ou por um único componente em cada lado. Isso não é realmente uma boa explicação, mas se você entender como o swing funciona, você mesmo poderá conectar os pontos.

Como eu mencionei antes, eu escrevi o código para isso, mas é longo e difícil de seguir, e eu posso postar aqui, se alguém mostrar o desejo de vê-lo. E eu estou falando sobre o próprio SSCCE. Realmente não pode ser encurtado em um par de 10s de linhas de código.

O que eu quero é deixar de escrever um algoritmo que mantenha a estrutura do "documento" e mova todos os elementos, já que é uma coisa muito complicada de se fazer, tomando todos os numerosos casos.

O que eu quero é uma alternativa e estou perguntando se você tem alguma idéia. Uma coisa que me veio à mente é ter um componente semelhante ao JPanel. Teria partes de altura fixas que podem ser preenchidas com outros componentes, e entre elas, partes de altura fixas que são impopuláveis ​​(?) Ou "sólidas".

O modo como funcionaria seria que toda vez que você adicionasse algo a partes populares (?), Elas seriam automaticamente rearranjadas. Se algo não se encaixa na parte populável atual, ela é movida para a próxima (semelhante a como funciona o layout de caixa vertical, adicionar uma coisa a um ponto empurra todas as outras para baixo), mas ignorando a parte sólida.

Como eu também teria que saber em qual parte populável um determinado componente é, não sei se criar uma estrutura desse tipo é possível no Java swing.

Bem, qualquer conselho é bem-vindo, bibliotecas externas incluídas.

Apenas tenha em mente que todo este documento é um documento com páginas que seriam colocadas uma após a outra na viewport de um JScrollPane, e esse é o único limite para o que deve parecer.