&&
------------------------------------------------------------------------------
                 CURSUS AMIGABASIC  -  SUBROUTINES  -  Block
------------------------------------------------------------------------------

Block is een routine die een tekst-regel aanpast aan een opgegeven lengte. De
routine voegt spaties toe zodat de tekst een gelijke linker- en rechter-kant
krijgt.

Het programma is als een SUB geschreven en heeft 2 parameters nodig.

SYNTAX :

CALL Block (t$,j%)

t$ = De tekstregel.
j% = Het aantal tekens dat het moet worden.

VOORBEELD :

   REM DEMO
   FOR I=1 TO 6                               :REM Zes regels.
       READ t$                                :REM Lees een regel in t$.
       j%=50                                  :REM 50 tekens per regel.
       IF LEN(t$)>j% THEN j%=LEN(t$)          :REM Test op de lengte.
       CALL Block (t$,j%)                     :REM Roep de routine aan.
       PRINT t$                               :REM Print de tekst.
   NEXT I
&&
   DATA "Dit zijn een aantal regels die elk vijftig"
   DATA "tekens lang moeten worden door het bij-"
   DATA "voegen van extra spaties. Elke regel wordt"
   DATA "door de subroutine gezonden en daarna op"
   DATA "het scherm geprint. De tekst is 6 regels"
   DATA "lang. Dit is de laatste regel van de tekst."
   END

DE EIGENLIJKE SUB :

   SUB Block (t$,j%) STATIC

Als eerste hebben we de lengte van de tekst nodig om deze in letters te split-
sen. We dimensioneren daarvoor het array w$.

       a=LEN(t$)
       DIM w$(a)

Nu moeten we de extra spaties aan het begin en aan het eind van de tekst af-
halen. We testen de tekens op spaties.

       p=0                                    :REM 0 Tekens van het einde.
       z$=" "                                 :REM Testen op spatie.
       WHILE z$=" "                           :REM De lus.
          z$=MID$(t$,a-p,1)                   :REM Pak een teken uit de tekst.
          p=p+1                               :REM 1 Teken verder in de tekst.
       WEND                                   :REM Einde van de lus.
&&
       p=p-1
       t$=LEFT$(t$,a-p)                       :REM Geen spatie meer aan eind.
       p=1
       z$=" "
       WHILE z$=" "                           :REM Dezelfde lus maar nu voor
          z$=MID$(t$,p,1)                     :REM    het begin van de tekst.
          p=p+1
       WEND
       p=p-2
       t$=RIGHT$(t$,a-p)                      :REM Geen spatie meer aan begin.
       IF j%<a THEN EXIT SUB                  :REM 50 Tekens tekst ? Dan stop.
       IF a<2 THEN EXIT SUB                   :REM 1 Teken tekst ? Dan stop.

Nu gaan we de tekst splitsen in woorden.

       k=1                                    :REM Aantal woorden.
       FOR z=1 TO a-p                         :REM Lus door de tekst.
           s$=MID$(t$,z,1)                    :REM Pak een letter.
           IF s$<>" " THEN w$(k)=w$(k)+s$     :REM Test op een spatie tussen woord.
           IF s$=" " THEN k=k+1
       NEXT z                                 :REM Einde regel.
&&
Nu moeten we de spaties evenredig verdelen over de tekstregel.

       DIM le%(k)
       b=j%-LEN(t$)
       z=0
       WHILE b>0                              :REM Aantal spaties.
          le%(z)=le%(z)+1                     :REM Voeg spatie toe.
          z=z+1
          IF z=(k) THEN z=1
          b=b-1
       WEND                                   :REM Alles toegevoegd.

Nu moeten we de nieuwe tekststring aanmaken om deze terug te geven aan het
hoofdprogramma.

       t$=""                                  :REM Lege start-string.
       FOR z=1 TO k                           :REM Lus voor aantal woorden.
           t$=t$+w$(z)+SPACE$(le%(z)+1)       :REM Aan elkaar plakken.
       NEXT z
       ERASE w$,le%                           :REM Wis de gebruikte array's.
   END SUB



Het programma staat op diskette onder de naam Block in de Basic-directory.

- EINDE ----------------------------------------------------------------------
&&