Wie geht Wordwrap oder gibt es eine SLE-Group

[Rolf]

Hallo

Entschuldigt das ich erst mal etwas drum herum reden muss.

Ich habe ein Vorgegebenes Formular in Papierform. Diese ist schon als Bild auf einem Dialog gebetet mit mehreren SLEs darauf, welche wiederuminhaltlich zusammengehören. Die Anzahl der Zeilen ist fest definiert (nicht mehr und nicht weniger), genauso wie die Anzahl der Zeichen pro Zeile.

Das sieht dann ungefähr so aus.

Bsp.:

Fall A (einfach):

Bemerkung :
############################### <= SLE1
############################### <= SLE2
############################### <= SLE3

Fall B (kommt aber auch vor):

Bemerkung : #################### <= SLE1
############################### <= SLE 2
################# <= SLE3

Fragen:

Gibt es eine Komponente, so eine Art Gruppenelement für SLE's, wo so etwas wie automatischer Zeilenumbruch funktioniert.

Gibt es ein MLE, welches auch auf Zeilen und Zeichen festgesetzt werden kann, mit irgend einer Art von Picturemaske? (zumindest Lösung für Fall A)

Hat jemand schon mal einen automatischen Zeilenumbruch programmiert?

Meine Versuche mit MemoLine(), MlCtoPos(), MPostoLc()... scheitern schon seit mehreren Anläufen.

Danke schon mal.
Rolf

[Martin Altmann]

Hallo Rolf,
stelle Dich doch bitte mal kurz in dem Vorstellungsforum vor - vielen Dank!
Nun zu Deiner Frage, von der ich nicht weiß, ob ich sie auch richtig verstehe.
Du solltest statt der SLEs lieber ein MLE nehmen! Durch die Breite des MLEs definierst Du ja, wieviele Zeichen in eine Zeile maximal passen. Am Ende der Zeile wird automatisch umbrochen und es geht in der nächsten Zeile weiter. Das sind die sogenannten "weichen" Zeilenwechsel.
Die Anzahl der Zeichen im MLE müßte während der Eingabe abgefragt werden und eine weitere Eingabe bei Erreichen der maximalen Zeichen- bzw. Zeilenanzahl unterbunden werden.
Geht das in etwa in die Richtung, die Du brauchst??

Viele Grüße,
Martin

[brandelh]

Hallo,

von einem SLE ins nächste sollte mit

Code: Alles auswählen

oXbp:autotab := .t.

machbar sein, zumindest wenn die Anzahl der Eingabezeichen voll ist.
Ein Return zum Zeilenumbruch kann man auch hinbekommen.

Das ganze scheint aber doch recht DOS-mäßig gedacht zu sein.
Dem Anwender wäre sicherlich mit einem MLE besser gedient.
Zum Beispiel: beim Löschen von Zeichen kommen die aus der nächsten Zeile wieder zurück, das ist mit SLE nicht zu schaffen.

Eine Begrenzung auf einzelne Zeichen habe ich bei SLE schon in das Keyhandling programmiert, ist nicht ganz trivial aber auch kein Kunstwerk.

Falls es bei der Eingabe um die Formatierung für einen Ausdruck geht, den kann man nachträglich auch machen.

Falls meine Antwort an der Frage vorbei ging, bitte nachhaken...

[Rolf]

Hallo

Ich stell mich gleich vor und fang auch so ein bisschen an.

Ich habe einen leeren Rentenantrag vor mir der wird eingescannt SLE's drauf, ... , speichern und drucken. Das klappt schon gut mit kleinen Formularen aber nun schlägt der Rentenantrag mit 3 A4 Seiten zu.

Das mit dem MLE ist schon richtig hab ich auch ausprobiert so mit einer festen Schrift (Courier). Hab es damals leider auch nicht hinbekommen das Ende abzufangen. Das wäre dann auch die Notlösung, mich daran nochmal zu versuchen.

Bisher hab ich das, bei kleinen Formularen (A5) mit SLE's und nun auch hier umgesetzt. Und Hubert hat vollkommen recht es ist recht DOS mäßig besonders bei meheren Seiten. Es ist aber leider nur so möglich Textblöcke wie in Fall B beschrieben darzustellen. Und diese sind leider auf dem Formular in Papierform vorgegeben.

Es wird sicherlich auch irgendwie mit MemoLine() gehen, aber bisher ist mir das zu komplex. Ich dachte, dass es eventuell ein Konzept für Wordwrap gibt.

[Tom]

Hallo, Rolf.

Erstmal: Herzlich willkommen im Forum!

Über den :GetBuffer()-Slot eines MLEs kannst Du jederzeit feststellen, wieviele Zeichen (und welche) ein MLE enthält, und darauf reagieren, indem Du zum Beispiel einfach ein neues abschneidest (und den veränderten Text mit :SetBuffer() zurückschreibst). Über den :KeyBoard()-Slot eines SLEs und eines MLEs kannst Du exakt überwachen, welche Zeichen eingetippt wurden oder ob überhaupt getippt wird (feuert immer, wenn ein Zeichen eingegeben wurde bzw. die Tastatur genutzt wurde, so daß man von hieraus überwachen kann, was in den SLEs/MLEs geschieht). Um Dir aber genauer dabei helfen zu können, das hinzukriegen, wäre ein Stückchen Code hilfreich.

[brandelh]

Hallo,

ich meine, dass der Keyboard() Slot erst tätig wird, wenn das Zeichen schon verarbeitet wurde. Für eine weitergehende Kontrolle müßte man das SLE ableiten und eine eigene Keyboard Methode schreiben.

Wenn es aber nur darum geht, dass du nach dem letzten Zeichen des SLE1 in das SLE2 kommst,
müsste :autotab := .t. reichen.

Ich habe z.B. einem SLE beigebracht nur Zahlen und Punkte für ein Datum zu akzeptieren, nicht perfekt, aber ich könnte das bei Gelegenheit einstellen.

[Rolf]

Ok ein bisschen Code

@Hubert das mit dem Keyboard()-Event stimmt, aber in der Eventschleife in der create()-Funktion des Dialoges geht das schonmal.

Aufruf aus der Eventschleife Dialog:create()
ist aber noch weiter verschachtelt

Code: Alles auswählen

//-- Normale Taste
case (nEvent == xbeP_Keyboard).AND.(mp1 >= 32 .AND. mp1 < 255)
     if( ::ChkKey( mp1, oXbp ) )
          oXbp:HandleEvent ( nEvent, mp1, mp2 )
     endif

Methode chkKey()

Code: Alles auswählen

METHOD clsFrmAMR_LVA:chkKey(nKey, oXbp)

    //** DEC VAR
    LOCAL bReturn := .T.
    LOCAL cText := ""

    LOCAL iMarked   := 1
    LOCAL iMax      := 63
    LOCAL cData     := oXbp:getData()
    LOCAL aChrPos   := {}
    LOCAL iRow      := 0


    LOCAl cText1 := ""
    LOCAl cText2 := ""
    LOCAl cText3 := ""
    LOCAl cText4 := ""
    LOCAl cText5 := ""
    LOCAl cText6 := ""
    LOCAl cText7 := ""
    LOCAL aXbps  := {}


    aAdd( aXbps, ::oSleBeschwer1)
    aAdd( aXbps, ::oSleBeschwer2)
    aAdd( aXbps, ::oSleBeschwer3)
    aAdd( aXbps, ::oSleBeschwer4)
    aAdd( aXbps, ::oSleBeschwer5)
    aAdd( aXbps, ::oSleBeschwer6)
    aAdd( aXbps, ::oSleBeschwer7)

    //Msg(,cData[iMax]+"|"+str(Len(cData)))
    //cData := substr(cData+Space(iMax),1,iMax)
    if (Len(cData)>=iMax).And.(cData[iMax] <> " ")
        //-- Hier muss nun der Zeilenumbruch erfolgen,
        //--  da das letzte Zeichen ein Buchstabe ist
       // Msg(,"Is")


        //-- Wordwarp ---------------------------------------------

        //-- Kursorposition merken
        iMarked := oXbp:queryMarked()[1]

        //-- Alle Zeilen auslesen
        cText1 := ::oSleBeschwer1:getData()
        cText2 := ::oSleBeschwer2:getData()
        cText3 := ::oSleBeschwer3:getData()
        cText4 := ::oSleBeschwer4:getData()
        cText5 := ::oSleBeschwer5:getData()
        cText6 := ::oSleBeschwer6:getData()
        cText7 := ::oSleBeschwer7:getData()


        //-- Zeichen einf�gen
        do case
        case oXbp == ::oSleBeschwer1
            cText1 := substr(cText1, 1, iMarked-1) +CHR(nKey) + substr(cText1, iMarked)
            iRow := 1
        case oXbp == ::oSleBeschwer2
            cText2 := substr(cText2, 1, iMarked-1) +CHR(nKey) + substr(cText2, iMarked)
            iRow := 2
        case oXbp == ::oSleBeschwer3
            cText3 := substr(cText3, 1, iMarked-1) +CHR(nKey) + substr(cText3, iMarked)
            iRow := 3
        case oXbp == ::oSleBeschwer4
            cText4 := substr(cText4, 1, iMarked-1) +CHR(nKey) + substr(cText4, iMarked)
            iRow := 4
        case oXbp == ::oSleBeschwer5
            cText5 := substr(cText5, 1, iMarked-1) +CHR(nKey) + substr(cText5, iMarked)
            iRow := 5
        case oXbp == ::oSleBeschwer6
            cText6 := substr(cText6, 1, iMarked-1) +CHR(nKey) + substr(cText6, iMarked)
            iRow := 6
        case oXbp == ::oSleBeschwer7
            cText7 := substr(cText7, 1, iMarked-1) +CHR(nKey) + substr(cText7, iMarked)
            iRow := 7
        endcase

        //-- Text zusammenf�gen
        cText := cText1
        cText += cText2
        cText += cText3
        cText += cText4
        cText += cText5
        cText += cText6
        cText += cText7

        //-- Text neu Trennen
        cText1 := MemoLine(cText,iMax,1,8,.T.)+" "
        cText2 := MemoLine(cText,iMax,2,8,.T.)+" "
        cText3 := MemoLine(cText,iMax,3,8,.T.)+" "
        cText4 := MemoLine(cText,iMax,4,8,.T.)+" "
        cText5 := MemoLine(cText,iMax,5,8,.T.)+" "
        cText6 := MemoLine(cText,iMax,6,8,.T.)+" "
        cText7 := MemoLine(cText,iMax,7,8,.T.)+" "

        cText := cText1+cText2+cText3+cText4+cText5+cText6+cText7

        //-- Text neu setzen
        ::oSleBeschwer1:setData(RTrim(cText1))
        ::oSleBeschwer2:setData(RTrim(cText2))
        ::oSleBeschwer3:setData(RTrim(cText3))
        ::oSleBeschwer4:setData(RTrim(cText4))
        ::oSleBeschwer5:setData(RTrim(cText5))
        ::oSleBeschwer6:setData(RTrim(cText6))
        ::oSleBeschwer7:setData(RTrim(cText7))



        //iMarked := iMarked+1// := MlCtoPos( cText , iMax, iRow, iMarked-1, 8 , .T. )


        //-- Wenn Kursor am Ende der Zeile Kursor mit auf n„chste Zeile nehmen
        //-- Wenn Kursor in der Mitte und letzte


        //cText := RTrim(cText1)+" "+RTrim(cText2)+" "+RTrim(cText3)+" "+RTrim(cText4)+" "+;
                        RTrim(cText5)+" "+RTrim(cText6)+" "+RTrim(cText7)+" "

        //iMarked := Len(cText)
        //Msg(,iMarked)
        //Msg(,Len(cText))


        cText := ::oSleBeschwer1:getData()+::oSleBeschwer2:getData()+;
                     ::oSleBeschwer3:getData()+::oSleBeschwer4:getData()+;
                     ::oSleBeschwer5:getData()+::oSleBeschwer6:getData()+;
                     ::oSleBeschwer7:getData()

        iMarked := MlCtoPos( cText , iMax, iRow, iMarked, 8 , .T. )
        aChrPos := MPostoLc( cText, iMax, iMarked+1, 8, .T.)

        SetAppFocus(aXbps[ aChrPos[1]+1 ])

        aXbps[ aChrPos[1]+1 ]:setMarked( {aChrPos[2]+1,aChrPos[2]+1} )


        //-- Wordwarp ---------------------------------------------
        bReturn := .F.
    else
        //-- Auch wenn es nur ein Leer zeichen ist
        //-- Zeichenanzahl nicht �berschreiten
        if(Len(cData) == iMax)
            bReturn := .F.
        else
            bReturn := .T.
        endif
    endif
RETURN bReturn

Ist alles ein bisschen einfach aber ich dachte so seh ich durch

Die ersten zwei SLEs stimmen schon so ein bisschen, aber beim dritten wird der Kursor falsch positioniert und und und...

Danke schonmal

[Tom]

Shit. Ich habe natürlich GetData() und SetData() gemeint. Leicht dement heute. Liegt am Wetter.

[Rolf]

Mit dem MLE geht das recht einfach wenn man die Mausereignisse erstmal weg lässt.

zu beachten das MLE muss wie folgt gefüllt werden sonst funktioniert irgendwie MPosToLc nicht:

Code: Alles auswählen

        ::oMleKranGes:setData(  Chr(13)+Chr(10)+ Chr(13)+Chr(10)+ Chr(13)+Chr(10)+ ;
                                Chr(13)+Chr(10)+ Chr(13)+Chr(10)+ Chr(13)+Chr(10)+ ;
                                Chr(13)+Chr(10)+Chr(13)+Chr(10))

8* der Zeilenumbruch auch wenn man nur 7 Zeilen braucht. Sonst ist der Rückgabewert von MPosToLC(...)[1] = 0

Wieder in Eventschleife Dialog:create()

Code: Alles auswählen

METHOD clsFrmAMR_LVA:handleMleEvents(nEvent, mp1, mp2, oXbp)
    //** DEC VAR
    LOCAL iMax := 63*7
    LOCAL cTemp := ""
    LOCAL cText := ""
    LOCAL iMarked := 0
    LOCAL aChrPos  :={}

    if(nEvent == xbeP_Keyboard)

        //-- Position in kompletten String
        cTemp   := oXbp:editbuffer()
        iMarked := oXbp:queryMarked()[1]
        aChrPos := MPostoLc( cTemp, 63, iMarked, 8, .T.)

        //Msgbox(str(iMarked)+str(aChrPos[1])+str(aChrPos[2]))

        if( aChrPos[1] > 0 ).And.(aChrPos[1] < 7 )
            oXbp:HandleEvent( nEvent, mp1, mp2 )
        else
            //-- NIX
        endif
    else
        oXbp:HandleEvent( nEvent, mp1, mp2 )
    endif

Ich schau mir nochmal die Mausereignisse an und Suche noch nach Sonderfällen.

[brandelh]

Hallo Rolf,

Aufruf aus der Eventschleife Dialog:create()

du meinst doch sicher die Eventloop nachdem der Dialog angezeigt wurde oder ?

Methode chkKey()
METHOD clsFrmAMR_LVA:chkKey(nKey, oXbp)

du rufst die Umbruchroutine bei jedem Zeichen auf, ist das nicht sehr langsam bzw. unruhig am Bild ?

cText1 := ::oSleBeschwer1:getData()
cText2 := ::oSleBeschwer2:getData()
cText3 := ::oSleBeschwer3:getData()
cText4 := ::oSleBeschwer4:getData()
cText5 := ::oSleBeschwer5:getData()
cText6 := ::oSleBeschwer6:getData()
cText7 := ::oSleBeschwer7:getData()

falls du einen Codeblock in :datalink hinterlegt hast, würde mit jedem :getData() der Datensatz gespeichert. Für deine Aktionen ist :editBuffer() besser geeignet.

Ist alles ein bisschen einfach

Ich denke dein code sollte einfacher werden. Das dauernde Zerhacken und Zusammenfügen von Strings kostet eine Menge Zeit, memoline ist auch recht lahm.
Eine Optimierung wäre, dass du nur ab der aktuellen Zeile prüfst. Du übergibst ja den aktiven oXbp.
Wenn in der Zeile noch genug Platz ist für ein Zeichen ist, füge es ein und lass den Rest in Ruhe. Wenn nicht, suchst du in dieser Zeile nach dem letzten Wort
und siehst nach ob das umzubrechende Wort in die nächste Zeile passt. Nur wenn das nicht reicht, mehrere Zeilen abarbeiten.
Beim Löschen von Zeichen geht es ähnlich.

Insgesamt ein komplexes Vorhaben. Erinnert mich ein bischen an meine 'frühen Jahre' als ich einen Texteditor mit meinem Basic Compiler geschrieben habe.

[AUGE_OHR]

hi,

mal eine Frage : warum "nur" 1 Memofeld ... nimm doch für jedes SLE
ein neues Memofeld in der DBF.

gruss by OHR
Jimmy

[Rolf]

Hallo Hubert

Ja den Eventloop meine ich

Code: Alles auswählen

    
DO WHILE .t.
   nEvent := AppEvent ( @mp1, @mp2, @oXbp )
   //oXbp:HandleEvent ( nEvent, mp1, mp2 )

Ich hab erstmal einen Weg gesucht der funktioniert und überschaubar ist später hätte ich eventuell noch optimiert.

Das mit nur auf eine Zeile schauen hab ich auch schon so ein bisschen probiert ist dann an der Komplexität der möglichen Ereignisse gescheitert.

1. Zeichen am Ende einfügen
2. Zeichen von hinten an löschen
3. Zeichen in der mitte hinzufügen
4. Zeichen aus der mitte entfernen
....

Man könnte natürlch irgendwie rekursiv, das Zeichen falls es nicht mehr auf eine Zeile passt, als Event weiter an das nächste SLE schicken. das scheint aber auch nicht sehr einfach zu sein.

Könnte man ein unsichtbares MLE verwenden und die gleichen Events auch an dieses schicken? Aber das ist zu verückt.

hm also doch erstmal zu komplex

[Martin Altmann]

Hallo Jimmy,
was soll ihm das bringen
Er möchte einen (maximal) dreizeiligen Text erfassen können, bei dem jede Zeile nicht mehr als eine bestimmte Anzahl Zeichen enthalten darf.
Halt ein typische Behörden-Formular (denke mal an die Steuererklärung, da hast Du auch in jeder Zeile, in die Du was eintragen darfst, eine zeichenweise Unterteilung).

Viele Grüße,
Martin

[AUGE_OHR]

hi,

was soll ihm das bringen
Halt ein typische Behörden-Formular (denke mal an die Steuererklärung, da hast Du auch in jeder Zeile, in die Du was eintragen darfst, eine zeichenweise Unterteilung).

aha, so langsam macht es "click" ...

dann ist mit "automatischer Zeilenumbruch" eigendlich gemeint das
er vom SLE1 "weiterspringt" zu SLE2 wenn er am "Ende" von SLE1
angekommen ist ?

wenn ja, probiere mal SLEPIC. Das verhäldt sich so ( wie Cl*pper )

gruss by OHR
Jimmy

[Martin Altmann]

Hallo Jimmy,
genau!
Nur bei einem SLE hat er natürlich das Problem, das Zeichen aus dem nächsten SLE hochrutschen müssen, wenn im aktuellen SLE Zeichen gelöscht werden.
Und umgekehrt - werden im aktuellen SLE Zeichen eingefügt, müssen die am Ende "rausfallenden" Zeichen ins nächste SLE verschoben werden.
Darum statt SLE MLE, da dies dort ein wenig einfacher zu lösen sein sollte.

Viele Grüße,
Martin

[Wolfgang Ciriack]

Ich denke auch ein MLE mit max. Anzahl einzugebener Zeichen ist vorteilhafter.
Einen kleinen Puffer lassen um noch Platz für die evtl. bei der Aufteilung der Eingabe in 3 Zeilen entstehende Leerzeichen zu haben.
Die Aufteilung der Eingabe würde ich mit der Tokenfunktion aus den Tools vornehmen.

[Tom]

Nur bei einem SLE hat er natürlich das Problem, das Zeichen aus dem nächsten SLE hochrutschen müssen, wenn im aktuellen SLE Zeichen gelöscht werden.

Das geht doch mit :KeyBoard, :SetData und :GetData.

Und ein MLE kommt, wenn ich das richtig verstehe, nicht in Frage, weil die voneinander abhängigen Zeilen verschieden lang und positioniert sein können.

[brandelh]

:GetData()

wie gesagt, vorsicht mit :getdata() das führt den datalink codeblock aus, besser beim Lesen für solche Aktionen grundsätzlich :editbuffer() nutzen

[Martin Altmann]

Hallo Tom,
klar geht das auch mit einem SLE zu realisieren - aber die Funktionalität muss man erst reinprogrammieren! Und ein MLE kann das schon -> weniger Aufwand.

Und ein MLE kommt, wenn ich das richtig verstehe, nicht in Frage, weil die voneinander abhängigen Zeilen verschieden lang und positioniert sein können.

Ehm, nein! Die Zeilen können unterschiedlich viele Zeichen enthalten (klar!), aber dürfen alle eine bestimmte Maximallänge nicht überschreiten!

Code: Alles auswählen

Dies ist der Text in der ersten Zeile und
das Wort "das" hat in die erste Zeile leider
nicht mehr reingepasst!

So habe ich das zumindest verstanden

Viele Grüße,
Martin

[brandelh]

Hallo Martin,

ich vermute dass das Programm so aussehen soll wie z.B. Taxman und da wären SLE vermutlich schöner über dem Hintergrund. Aber die Steuerung wird nicht einfach.

[Rolf]

Hallo

Das mit dem MLE klappt schon gut. Ich stell den Code rein wenn ich fertig bin. In der Regel sind auch auf den Formularen feste Blöcke, (wie ganz oben beschrieben Fall A).

Aber es gibt auch Sonderfälle wie zum Bsp. das Überweisung-Formular bei der Eingabe der Diagnose sieht das so aus wie in Fall B.

Muss man nochmal nachdenken und ggf. noch reifen lassen.

Danke für die bisherige Mühe und das ihr euch mit meinen Sorgen zusätzlich plagt.

Rolf

[brandelh]

Hallo,

ich habe meinen Formularärger dahingehend beseitigt, dass ich alles selbst drucke.

[Rolf]

Hallo Hubert

Den Text auf die Formulare zu drucken, dass funktioniert. Die Formulare selbst kann ich nicht verändern, da sie von der KBV vorgegeben sind. (KBV = Kassenärztliche BundesVereinigung).

Die Anwender finden es schöner das Formular per WYSIWYG auszufüllen.

Ich prog schon die ganze Zeit an dem MLE. Wenn man solche Ereignisse wie Markierung und Scrollen mit der Maus oder Schift+Down abfangen will... naja

Ich glaub das mit den SLE's muss erstmal unter den Tisch fallen.
Die Zeit wird langsam knapp.

Danke

[Rolf]

Hi

Ich stell noch schnell meine
(für mich erstmal ausreichende) Lösung ins Netz.

Code: Alles auswählen

METHOD clsFrmAMR_LVA:handleMleEvents(nEvent, mp1, mp2, oXbp)
    //** DEC VAR
    LOCAL iMax          := 63 //-- Maximale Zeichen pro Zeile
    LOCAL iLines        := 10 //-- Anzahl der Zeilen
    LOCAL bHandleNormal := .T.//-- Normal reagieren
    LOCAL iLine         := 0  //-- Aktuelle Zeile
    LOCAL iChar         := 0  //-- Aktuelles Zeichen auf der Zeile
    LOCAL iPos          := 0  //-- Position in Zeichenkette
    LOCAL cTemp         := "" //-- Gesamtinhalt
    LOCAL aMarked       := {} //-- für QueryMarked

    //** Blockgröße ermitteln
    do case
        case (oXbp == ::oMLEKranGes).or.(oXbp == ::oMLEBelast).or.;
               (oXbp == ::oMleBefund)
            iLines  := 9
        case (oXbp == ::oMLEBeschwer)
            iLines  := 7
        case (oXbp == ::oMLEThera)
            iLines  := 5
        case (oXbp == ::oMLEBemerk)
            iLines  := 3
    endcase

    //** Tastaturereignisse
    if(nEvent == xbeP_Keyboard)
        //Msg(,mp1)
        //-- Inhalt in  String
        cTemp   := oXbp:editbuffer()

        //-- Position im Editbuffer
        aMarked := oXbp:queryMarked()
        iPos := aMarked[2]
        if(aMarked[1] > aMarked[2])
            iPos := aMarked[1]
        endif

        //iPos  := oXbp:pos() geht nicht sobald zwei Zeichen markiert sind
        iLine := oXbp:lineFromChar()
        iChar := oXbp:charFromLine( iLine ) //-- Anfangsposition der Zeile
        iChar := iPos-iChar   //-- Position auf der Zeile

        //-- Alles noch im Rahmen
        if( iLine > 0 ).And.(iLine <= iLines )
            do case
                //-- Letzte Zeile ist maximal gef