1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls, Buttons;

type
  TfrmKodierung = class(TForm)
    gbxSatz: TGroupBox;
    gbxCode: TGroupBox;
    edtCodeBuchstabe: TEdit;
    lblCodeBuchstabe: TLabel;
    bbtnEnde: TBitBtn;
    bbtnNeu: TBitBtn;
    bbtnCode: TBitBtn;
    mmoSatz: TMemo;
    procedure FormCreate(Sender: TObject);
    procedure mmoSatzChange(Sender: TObject);
    procedure bbtnCodeClick(Sender: TObject);
  private
    { Private-Deklarationen}
  public
    { Public-Deklarationen}
  end;

var
  frmKodierung: TfrmKodierung;

implementation

{$R *.DFM}

 VAR CodeRichtung  : -1 .. 1;

procedure TfrmKodierung.FormCreate(Sender: TObject);
begin
   gbxSatz.Caption  := 'Geben Sie den zu verschlüsselnden Text ein:';
   WITH mmoSatz DO
      BEGIN
         Text    := '';
         Enabled := true
      END;
   WITH edtCodeBuchstabe DO
      BEGIN
         Text    := '';
         Enabled := true
      END;
   bbtnCode.Enabled := false;
   CodeRichtung     := 1 // d.h. als erstes wird kodiert
end;

procedure TfrmKodierung.mmoSatzChange(Sender: TObject);
begin
   IF (mmoSatz.Text <> '') AND (edtCodeBuchstabe.Text <> '')
    THEN bbtnCode.Enabled := true
    ELSE bbtnCode.Enabled := false;
end;

 FUNCTION EinLesen(AnzeigeText : STRING) : STRING;
    var zwtext:string;
        zeichen:integer;
    BEGIN
       Zwtext:='';
       For zeichen:=1 to length(anzeigetext) do
        case anzeigetext[zeichen] of
        'a'..'z','A'..'Z':zwtext:=zwtext+uppercase(anzeigetext[zeichen]);
        'ä','Ä'          :zwtext:=zwtext+'AE';
        'ö','Ö'          :zwtext:=zwtext+'OE';
        'ü','Ü'          :zwtext:=zwtext+'UE';
        'ß'              :zwtext:=zwtext+'SS';
        'â','á','à'      :zwtext:=zwtext+'A';
        'ê','é','è'      :zwtext:=zwtext+'E';
        'û','ú','ù'      :zwtext:=zwtext+'U';
        'ô','ó','ò'      :zwtext:=zwtext+'O';
        'î','í','ì'      :zwtext:=zwtext+'I';
        '°'              :zwtext:=zwtext+'GRAD';
        '@'              :zwtext:=zwtext+'AT';
        '_'              :zwtext:=zwtext+'UNTERSTRICH';
        '1'              :zwtext:=zwtext+'EINS';
        '2'              :zwtext:=zwtext+'ZWEI';
        '3'              :zwtext:=zwtext+'DREI';
        '4'              :zwtext:=zwtext+'VIER';
        '5'              :zwtext:=zwtext+'FUENF';
        '6'              :zwtext:=zwtext+'SECHS';
        '7'              :zwtext:=zwtext+'SIEBEN';
        '8'              :zwtext:=zwtext+'ACHT';
        '9'              :zwtext:=zwtext+'NEUN';
        '0'              :zwtext:=zwtext+'NULL';
        '"'              :zwtext:=zwtext+'ANFUEHRUNGSZEICHEN';
        '!'              :zwtext:=zwtext+'AUSRUFEZEICHEN';
        '?'              :zwtext:=zwtext+'FRAGEZEICHEN';
        '.'              :zwtext:=zwtext+'PUNKT';
        ','              :zwtext:=zwtext+'KOMMA';
        ';'              :zwtext:=zwtext+'SEMIKOLON';
        ':'              :zwtext:=zwtext+'DOPPELPUNKT';
        '-'              :zwtext:=zwtext+'MINUS';
        '+'              :zwtext:=zwtext+'PLUS';
        '%'              :zwtext:=zwtext+'PROZENT';
        '&'              :zwtext:=zwtext+'UND';
        '('              :zwtext:=zwtext+'KLAMMERAUF';
        ')'              :zwtext:=zwtext+'KLAMMERZU';
        '['              :zwtext:=zwtext+'ECKIGEKLAMMERAUF';
        ']'              :zwtext:=zwtext+'ECKIGEKLAMMERZU';
        '='              :zwtext:=zwtext+'ISTGLEICH';
        '²'              :zwtext:=zwtext+'HOCHZWEI';
        '³'              :zwtext:=zwtext+'HOCHDREI';
        '$'              :zwtext:=zwtext+'DOLLAR';
        '€'              :zwtext:=zwtext+'EURO';
        '*'              :zwtext:=zwtext+'STERNCHEN';
        '\'              :zwtext:=zwtext+'BACKSLASH';
        '/'              :zwtext:=zwtext+'SLASH';
        '#'              :zwtext:=zwtext+'RAUTE';
        {'10'             :zwtext:=zwtext+'ZEHN';
        '11'             :zwtext:=zwtext+'ELF';
        '12'             :zwtext:=zwtext+'ZWOELF';
        '13'             :zwtext:=zwtext+'DREIZEHN';
        '14'             :zwtext:=zwtext+'VIERZEHN';
        '15'             :zwtext:=zwtext+'FUENFZEHN';
        '16'             :zwtext:=zwtext+'SECHSZEHN';
        '17'             :zwtext:=zwtext+'SIEBZEHN';
        '18'             :zwtext:=zwtext+'ACHTZEHN';
        '19'             :zwtext:=zwtext+'NEUNZEHN';
        '20'             :zwtext:=zwtext+'ZWANZIG';
        '21'             :zwtext:=zwtext+'EINUNDZWANZING';
        '22'             :zwtext:=zwtext+'ZWEIUNDZWANZIG';
        '23'             :zwtext:=zwtext+'DREIUNDZWANZIG';
        '24'             :zwtext:=zwtext+'VIERUNDZWANZIG';
        '25'             :zwtext:=zwtext+'FUENFUNDZWANZIG';
        '26'             :zwtext:=zwtext+'SECHSUNDZWANZIG';
        '27'             :zwtext:=zwtext+'SIEBENUNDZWANZIG';
        '28'             :zwtext:=zwtext+'ACHTUNDZWANZIG';
        '29'             :zwtext:=zwtext+'NEUNUNDZWANZIG';
        '30'             :zwtext:=zwtext+'DREIZIG'; }






        end;
       Einlesen:=zwtext;
       // Diese Funktion soll dafür sorgen, dass in dem zu kodierenden
       // Text nur große Buchstaben stehen, Umlaute umgeschrieben und
       // Satzzeichen entfernt werden.
    END; // von EinLesen

 PROCEDURE Code(VAR C_Text  : STRING;
                C_Buchstabe : CHAR;
                C_Richtung  : SHORTINT);
      VAR index:integer;
          Verschiebung:shortint;
      BEGIN
      Verschiebung:=C_Richtung*(ord(C_Buchstabe)-ord('A'));
      FOR index:=1 to length(C_Text) do
          C_Text[Index]:=chr((ord(C_Text[Index])-ord('A')+Verschiebung+26)MOD 26+ORD('A'));
      // Hier soll die (De)Kodierung stattfinden.
   END;

 FUNCTION BlockAusgabe(AusgabeText : STRING) : STRING;
    CONST Block = 5; // <-- Anzahl der Buchstaben, die zu einem Block zusammengefasst werden
     VAR index:byte;
         zwtext:string;
    BEGIN
       for index:=1 to length(Ausgabetext) do
       begin
           ZwText:=Zwtext+Ausgabetext[index];
           if Index MOD block = 0
           then ZWText:=zwtext+' ';
       end;
       blockausgabe:=zwtext;
       // Diese Funktion soll den auszugebenden Text in Blöcke
       // der angegebnen Länge "zerhacken" und die einzelnen
       // Blöcke durch Leerzeichen trennen.
    END; // von BlockAusgabe

procedure TfrmKodierung.bbtnCodeClick(Sender: TObject);
 VAR  TextFeld      : STRING;
      CodeBuchstabe : CHAR;
begin
          
   TextFeld      := EinLesen(mmoSatz.Text);
   CodeBuchstabe := edtCodeBuchstabe.Text[1];
   Code(TextFeld, CodeBuchstabe, CodeRichtung);
   mmoSatz.Text  := BlockAusgabe(TextFeld);
   IF CodeRichtung = 1
    THEN
       BEGIN
          mmoSatz.Enabled          := false;
          edtCodeBuchstabe.Enabled := false;
          bbtnCode.Caption         := 'de&kodieren';
          gbxSatz.Caption          := 'kodierter Text:'
       END
    ELSE
       BEGIN
          mmoSatz.Enabled          := true;
          edtCodeBuchstabe.Enabled := true;
          bbtnCode.Caption         := '&kodieren';
          gbxSatz.Caption := 'Geben Sie den zu verschlüsselnden Text ein:'
       END;
   CodeRichtung  := -1 * Coderichtung;
end;

end.					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:

procedure btnEncryptClick(Sender: TObject);
var x,i,j,y,z: integer;
    letter, keyletter: char;
begin
  input:=lowercase(memText.Text);
  key:=lowercase(edtKey.Text);
  j:=1;
  for i:=1 to length(input) do
    begin
      letter:=input[i];
      if j>length(key) then
        begin
          j:=1;
        end;
      if letter in ['a'..'z'] then
        begin
          x:=alphabet.IndexOf(letter);
          keyletter:=key[j];
          y:=alphabet.IndexOf(keyletter);
          z:=x+y;
          j:=j+1;
          begin
          if z>25 then
            begin
              z:=z-26;
              letter:=alphabet[z][1];
            end
          else
            begin
              letter:=alphabet[z][1];
            end;
          end;
        end;
      input[i]:=letter;
    end;
  memText.Text:=input;
end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311:
312:
313:
314:
315:
316:
317:
318:
319:
320:
321:
322:
323:
324:
325:
326:
327:
328:
329:
330:
331:
332:
333:
334:
335:
336:
337:
338:
339:
340:
341:
342:
343:
344:
345:
346:
347:
348:
349:
350:
351:
352:
353:
354:
355:
356:
357:
358:
359:
360:
361:
362:

{

  *****************************************************************
  *                *
  *        Polyalphabetische Verschlüsselung      *
  *                *
  *  Substitutionsprinzip des Alphabets nach Caesar    *
  *                *
  *****************************************************************

  
           Ersteller:  <dein Name>


Programmhistory:
----------------

  v1.00  13.01.2007  Abwandlung der Monoalphabetischen zur Polyalphabetischen





}

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls, Buttons;

type
  TfrmKodierung = class(TForm)
    gbxCode: TGroupBox;
    edtCodeBuchstabe: TEdit;
    lblCodeBuchstabe: TLabel;
    bbtnEnde: TBitBtn;
    bbtnNeu: TBitBtn;
    bbtnCode: TBitBtn;
    gbxSatz: TGroupBox;
    mmoSatz: TMemo;
    OpenDia: TOpenDialog;
    SaveDia: TSaveDialog;
    btnopen: TButton;
    btnsave: TButton;
    procedure FormCreate(Sender: TObject);
    procedure mmoSatzChange(Sender: TObject);
    procedure bbtnCodeClick(Sender: TObject);
    procedure OpenDiaCanClose(Sender: TObject; var CanClose: Boolean);
    procedure btnopenClick(Sender: TObject);
    procedure btnsaveClick(Sender: TObject);
  private
    { Private-Deklarationen}
  public
    { Public-Deklarationen}
  end;

var
  frmKodierung: TfrmKodierung;

implementation

{$R *.DFM}

 VAR CodeRichtung  : -1 .. 1;

procedure TfrmKodierung.FormCreate(Sender: TObject);
begin
 mmoSatz.lines.clear;
 gbxSatz.Caption  := 'Geben Sie den zu verschlüsselnden Text ein:';
 CodeRichtung     := 1 // d.h. als erstes wird kodiert (<- ist totaler Schwachsinn, denn was passiert wenn du nen verschlüsselten Text lädst?
           //dann stimmt die Inversion, bzw. die Verschiebung nicht mehr und du verschlüsselst deinen verschlüsselten Text quasi
           //nochmal.
end;


procedure TfrmKodierung.mmoSatzChange(Sender: TObject);
var i: integer;
begin             //kann man hier noch machen dass ein ß zum SS wird und so? wie unten halt.. :) ? //warum da?
    IF (mmoSatz.Text <> '') AND (edtcodebuchstabe.text <> '')
    THEN bbtnCode.Enabled := true
    ELSE bbtnCode.Enabled := false;

end;

FUNCTION EinLesen(AnzeigeText : STRING) : STRING;
{

  Funktionsbeschreibung:  Diese Funktion wandelt alle im Text
        vorkommenden Zeichen in verwendbare
        Zeichen der ASCII-Tabelle im 
        Bereich von 65 - 90 um.

        A - Z

}
var zwtext:string;
    zeichen:integer;
BEGIN
       Zwtext:='';
       For zeichen:=1 to length(anzeigetext) do
        case anzeigetext[zeichen] of
        'a'..'z','A'..'Z':zwtext:=zwtext+uppercase(anzeigetext[zeichen]);
        'ä','Ä'          :zwtext:=zwtext+'AE';
        'ö','Ö'          :zwtext:=zwtext+'OE';
        'ü','Ü'          :zwtext:=zwtext+'UE';
        'ß'              :zwtext:=zwtext+'SS';
        'â','á','à'      :zwtext:=zwtext+'A';
        'ê','é','è'      :zwtext:=zwtext+'E';
        'û','ú','ù'      :zwtext:=zwtext+'U';
        'ô','ó','ò'      :zwtext:=zwtext+'O';
        'î','í','ì'      :zwtext:=zwtext+'I';
        '°'              :zwtext:=zwtext+'GRAD';
        '@'              :zwtext:=zwtext+'AT';
        '_'              :zwtext:=zwtext+'UNTERSTRICH';
        '1'              :zwtext:=zwtext+'EINS';
        '2'              :zwtext:=zwtext+'ZWEI';
        '3'              :zwtext:=zwtext+'DREI';
        '4'              :zwtext:=zwtext+'VIER';
        '5'              :zwtext:=zwtext+'FUENF';
        '6'              :zwtext:=zwtext+'SECHS';
        '7'              :zwtext:=zwtext+'SIEBEN';
        '8'              :zwtext:=zwtext+'ACHT';
        '9'              :zwtext:=zwtext+'NEUN';
        '0'              :zwtext:=zwtext+'NULL';
        '"'              :zwtext:=zwtext+'ANFUEHRUNGSZEICHEN';
        '!'              :zwtext:=zwtext+'AUSRUFEZEICHEN';
        '?'              :zwtext:=zwtext+'FRAGEZEICHEN';
        '.'              :zwtext:=zwtext+'PUNKT';
        ','              :zwtext:=zwtext+'KOMMA';
        ';'              :zwtext:=zwtext+'SEMIKOLON';
        ':'              :zwtext:=zwtext+'DOPPELPUNKT';
        '-'              :zwtext:=zwtext+'MINUS';
        '+'              :zwtext:=zwtext+'PLUS';
        '%'              :zwtext:=zwtext+'PROZENT';
        '&'              :zwtext:=zwtext+'UND';
        '('              :zwtext:=zwtext+'KLAMMERAUF';
        ')'              :zwtext:=zwtext+'KLAMMERZU';
        '['              :zwtext:=zwtext+'ECKIGEKLAMMERAUF';
        ']'              :zwtext:=zwtext+'ECKIGEKLAMMERZU';
        '='              :zwtext:=zwtext+'ISTGLEICH';
        '²'              :zwtext:=zwtext+'HOCHZWEI';
        '³'              :zwtext:=zwtext+'HOCHDREI';
        '$'              :zwtext:=zwtext+'DOLLAR';
        '€'              :zwtext:=zwtext+'EURO';
        '*'              :zwtext:=zwtext+'STERNCHEN';
        '\'              :zwtext:=zwtext+'BACKSLASH';
        '/'              :zwtext:=zwtext+'SLASH';
        '#'              :zwtext:=zwtext+'RAUTE';
        {'10'             :zwtext:=zwtext+'ZEHN';
        '11'             :zwtext:=zwtext+'ELF';
        '12'             :zwtext:=zwtext+'ZWOELF';
        '13'             :zwtext:=zwtext+'DREIZEHN';
        '14'             :zwtext:=zwtext+'VIERZEHN';
        '15'             :zwtext:=zwtext+'FUENFZEHN';
        '16'             :zwtext:=zwtext+'SECHSZEHN';
        '17'             :zwtext:=zwtext+'SIEBZEHN';
        '18'             :zwtext:=zwtext+'ACHTZEHN';
        '19'             :zwtext:=zwtext+'NEUNZEHN';
        '20'             :zwtext:=zwtext+'ZWANZIG';
        '21'             :zwtext:=zwtext+'EINUNDZWANZING';
        '22'             :zwtext:=zwtext+'ZWEIUNDZWANZIG';
        '23'             :zwtext:=zwtext+'DREIUNDZWANZIG';
        '24'             :zwtext:=zwtext+'VIERUNDZWANZIG';
        '25'             :zwtext:=zwtext+'FUENFUNDZWANZIG';
        '26'             :zwtext:=zwtext+'SECHSUNDZWANZIG';
        '27'             :zwtext:=zwtext+'SIEBENUNDZWANZIG';
        '28'             :zwtext:=zwtext+'ACHTUNDZWANZIG';
        '29'             :zwtext:=zwtext+'NEUNUNDZWANZIG';
        '30'             :zwtext:=zwtext+'DREIZIG'; }






        end;
       Einlesen:=zwtext;
end;

PROCEDURE Code(VAR C_Text  : STRING; C_Buchstabe : string; _Richtung  : SHORTINT);
{

  Funktionsbeschreibung:  Hauptbestandteil der Anwendung.
        Errechnet anhand der Formel

        Verschiebung:=C_Richtung*(ord(c_buchstabe[counter])-ord('A'));

        die Richtung und den neuen Buchstaben aus.      
    

}
var index:integer;     //Unsere Zählervaribale für den Text, Zeichen für Zeichen
    Verschiebung:shortint;  //Unsere Verschiebeposition des Alphabets
    counter: integer;    //Unsere Varibale, die Position festlegt, welchen Buchstaben wir aus dem PW zum Berechnen verwenden
BEGIN

 //Wir beginnen beim ersten Zeichen unseres Passwortes..
 counter:= 1;

 //..und beginnen dann, den Text Zeichen für Zeichen durchzugehen
 FOR index:=1 to length(C_Text) do
 begin
  //Errechnen hier die Verschiebung (c_buchstabe[counter]) dient als Ausgangsbasis für Berechnung
  Verschiebung:=C_Richtung*(ord(c_buchstabe[counter])-ord('A'));
  //Beim nächsten Zeichen, ist ein anderes vom Passwort dran
  inc(counter);
  //Sollte die Position allerdings größer als die Summe unserer Zeichen im Passwort sein
  if counter > length(c_Buchstabe) then
   counter:= 1; //beginnen wir wieder beim ersten Zeichen des Passwortes
  
  //Und ersetzen unser Textzeichen durch das durch die Verschiebung errechnete
  C_Text[Index]:=chr((ord(C_Text[Index])-ord('A')+Verschiebung+26)MOD 26+ORD('A'));
 end;
end;


FUNCTION BlockAusgabe(AusgabeText : STRING) : STRING;

{
  Funktionsbeschreibung:  Diese Funktion fasst unseren Text 
        in Blöcke zusammen.

        (Wozu, ist allerdings fraglich) zumindest für mich =)
}

CONST Block = 5; // <-- Anzahl der Buchstaben, die zu einem Block zusammengefasst werden
VAR index: integer; //index:byte; (warum byte? für Zählervariablen NUR integer-Typen verwenden!)
    zwtext:string;
BEGIN

 //WICHTIG: Funktionen zu Beginn immer leer setzen
 
 Blockausgabe:= '';

 for index:=1 to length(Ausgabetext) do
 begin
  ZwText:=Zwtext+Ausgabetext[index];
  {
  
  MODULO  

  MODULO gibt den GANZZAHLIGEN Rest einer Division wieder.

  Mit if Index MOD block = 0 then prüfen wir, ob unser aktueller Index des Textes, also Position im Text, sich durch 
        unsere Konstante Block mit einem Rest von 0 Teilen lässt.

  Dabei wird diese Rechenoperation durchgeführt:  Index dividiert durch Block = Ergebnis

  Beispiel:  4 mod 5 = 4, weil 4:5 nicht geht, bleibt also ein Rest von 4

      5 mod 5 = 0; weil 5:5 geht ohne Rest auf

  WICHTIG: Das Ergebnis (5:5=1) spielt keine Rolle!



  }
  if Index MOD block = 0 then   //Ist der Rest also 0 wissen wir, das wir einen Block auf 5 Zeichen zusammen haben
    ZWText:=zwtext+' ';    //und machen dies durch anfügen eines Leerzeichens (' ') deutlich
 end;
 
 //Funktionsrückgabe festsetzen
 blockausgabe:=zwtext;
END;

procedure TfrmKodierung.bbtnCodeClick(Sender: TObject);

{

  Funktionsbeschreibung:  Hier findet die Verarbeitung
        nachdem auf den "Kodieren"-Button
        geklickt wurde statt.

        

}
VAR  TextFeld      : STRING;
     CodeBuchstabe : string;
begin

 TextFeld      := EinLesen(mmoSatz.Text);
 codeBuchstabe := einlesen(edtCodeBuchstabe.text);
 edtCodeBuchstabe.text:= codeBuchstabe;
 Code(TextFeld, CodeBuchstabe, CodeRichtung);
 mmoSatz.Text  := BlockAusgabe(TextFeld);

   
 {          
  Isses so wichtig dass das folgende weggemacht wird?
  er wird mich ja fragen wieso ich seine Arbeit als nichtig ansehe xD  !?

 }

 {

  Warum ist dieser Programmteil nichtig?

  Wichtigster Grund:   Dein Lade-Routine (Möglichkeit Text zu laden)
      
        Falls du einen Text lädst, welcher bereits verschlüsselt ist, wird dieser wieder verschlüsselt.

        Warum? Weil die Inversion der Variable CodeRichtung zu diesem Zeitpunkt falsch gesetzt ist.
        
        Logischer Beweis:   Wurde das erste mal mit -3 Verschoben, wird beim nächsten mal wieder mit -3               verschoben, was bedeutet, dass die Verschiebung vom Originalzeichen jetzt
              -6 beträgt, und das verschlüsselte Zeichen um 3 nach links verschoben wurde.

              Demzufolge muss vorher die codeRichtung richtig invertiert werden, sprich
              es muss angegeben werden ob verschlüsselt (1) oder entschlüsselt (-1) wird.
            
        
          Wie? Eine Checkbox, bei der angegeben wird, ob ver- oder entschlüsselt werden soll.

 }

 {

   IF CodeRichtung = 1
    THEN
       BEGIN
          mmoSatz.Enabled          := false;
          edtCodeBuchstabe.Enabled := false;
          bbtnCode.Caption         := 'de&kodieren';
          gbxSatz.Caption          := 'kodierter Text:'
       END
    ELSE
       BEGIN
          mmoSatz.Enabled          := true;
          edtCodeBuchstabe.Enabled := true;
          bbtnCode.Caption         := '&kodieren';
          gbxSatz.Caption := 'Geben Sie den zu verschlüsselnden Text ein:'
       END;

 }

 //durch -1 * Variable, wird der Wert dieser Variable invertiert (aus 1 wird -1, aus -1 wird 1)

 CodeRichtung  := -1 * Coderichtung;
end;

procedure TfrmKodierung.OpenDiaCanClose(Sender: TObject;
  var CanClose: Boolean);
begin
  //im objektinspektor ist nur TXT eingestellt
  //???
end;

procedure TfrmKodierung.btnopenClick(Sender: TObject);
begin
if opendia.execute then
mmoSatz.lines.loadfromfile(opendia.filename);
end;

procedure TfrmKodierung.btnsaveClick(Sender: TObject);
begin
if savedia.execute then
mmoSatz.lines.savetofile(savedia.filename);
end;

end.