JTextArea frage

CyborgBeta · 24. Juli 2014 um 12:51

Einfache, schelle Frage: Ich hab eine JTextArea jta1. (Einfache Darstellung von auch mehrzeilige, Text) Was muss ich adden und im eigene, Listener überschreiben, wenn ich nur mitbekommen möchte, ob/wenn ein Zeichen eingetippt oder eingefügt wurde? :grr:

*** Edit ***

Habs mittlerweile herausgefunden: Über jta1.getDocument() und jta1.getDocument().addDocumentListener(new DocumentListener() { (sowie insertUpdate usw.) funktionierts eigentlich ganz gut.

Dadurch braucht man ja kein Menüs und keine Buttons.

Ich brauchte das Ganze für meinen Quelltext-Verdreher…

Crian · 25. Juli 2014 um 02:51

Das klingt fies!

CyborgBeta · 25. Juli 2014 um 05:49

Also aus so etwas:

[spoiler]```/*

To change this template, choose Tools | Templates
and open the template in the editor.
*/
package pkg16;

import java.awt.GridLayout;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.SwingUtilities;
import javax.swing.WindowConstants;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;

/**
*
*/
public class Main {

private static String verdrehen(String str) {
    try {
        String[] keys = "abstract assert boolean break byte case catch char class const continue default do double else enum extends final finally float for if goto implements import instanceof int interface long native new package private protected public return short static strictfp super switch synchronized this throw throws transient try void volatile while".split(" ");
        Arrays.sort(keys);
        HashMap<String, String> map = new HashMap<String, String>();
        for (String string : keys) {
            map.put(string, string);
        }
        int index = 1;
        Pattern pat = Pattern.compile("\\w{5,}");
        BufferedReader br = new BufferedReader(new StringReader(str));
        StringWriter sw = null;
        {
            int len = 16;
            while (len <= str.length()) {
                len <<= 1;
            }
            System.out.println("len = " + len);
            sw = new StringWriter(len);
        }
        PrintWriter pw = new PrintWriter(sw);
        String line;
        while ((line = br.readLine()) != null) {
            int start = 0;
            Matcher m = pat.matcher(line);
            while (m.find()) {
                pw.print(line.substring(start, m.start()));
                start = m.end();
                if (!map.containsKey(m.group())) {
                    map.put(m.group(), "irgendwas_" + index++);
                }
                pw.print(map.get(m.group()));
            }
            pw.println(line.substring(start));
        }
        pw.flush();
        return sw.toString();
    } catch (IOException ioeIgnore) {
        //ignore
        return null;
    }
}

private static Set<String> verdrehen1(String str, int idx, Set<String> set) {
    int newIdx = idx + 1;
    if (newIdx >= str.length()) {
        if (!set.contains(str)) {
            set.add(str);
            verdrehen1(str, 0, set);
        }
    } else {
        verdrehen1(str, newIdx, set);
        verdrehen1(str.substring(0, idx) + str.charAt(newIdx) + str.charAt(idx) + str.substring(newIdx + 1), newIdx, set);
    }
    return set;
}

/**
 * @param args the command line arguments
 */
public static void main(String[] args) throws IOException {
    // TODO code application logic here
    /*System.out.println(verdrehen1("Hallo", 0, new HashSet<String>()));
     System.out.println(verdrehen1("Hallo", 0, new TreeSet<String>()));

     String[] keys = "abstract assert boolean break byte case catch char class const continue default do double else enum extends final finally float for if goto implements import instanceof int interface long native new package private protected public return short static strictfp super switch synchronized this throw throws transient try void volatile while".split(" ");
     Arrays.sort(keys);
     HashMap<String, String> map = new HashMap<String, String>();
     for (String string : keys) {
     map.put(string, string);
     }
     int index = 1;
     Pattern pat = Pattern.compile("\\w{5,}");
     /*JFileChooser jfc = new JFileChooser();
     if (jfc.showOpenDialog(null) != JFileChooser.APPROVE_OPTION) {
     return;
     }
     File f1 = jfc.getSelectedFile();
     if (jfc.showSaveDialog(null) != JFileChooser.APPROVE_OPTION) {
     return;
     }
     File f2 = jfc.getSelectedFile();
     if (!f1.isFile() || !f1.canRead() || !f2.isFile() || !f2.canWrite() || f1.equals(f2)) {
     return;
     }*/
    JFrame jf = new JFrame("Pkg16");
    jf.setLayout(new GridLayout(1, 2));
    final JTextArea jta1 = new JTextArea();
    final JTextArea jta2 = new JTextArea();
    jf.add(new JScrollPane(jta1));
    jf.add(new JScrollPane(jta2));
    jta1.getDocument().addDocumentListener(new DocumentListener() {
        @Override
        public void insertUpdate(DocumentEvent e) {
            SwingUtilities.invokeLater(new Runnable() {
                @Override
                public void run() {
                    jta2.setText(verdrehen(jta1.getText()));
                }
            });
        }

        @Override
        public void removeUpdate(DocumentEvent e) {
            SwingUtilities.invokeLater(new Runnable() {
                @Override
                public void run() {
                    jta2.setText(verdrehen(jta1.getText()));
                }
            });
        }

        @Override
        public void changedUpdate(DocumentEvent e) {
            SwingUtilities.invokeLater(new Runnable() {
                @Override
                public void run() {
                    jta2.setText(verdrehen(jta1.getText()));
                }
            });
        }
    });
    jf.pack();
    jf.setSize(720, 540);
    jf.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
    jf.setVisible(true);
    /*BufferedReader br = new BufferedReader(new FileReader(f1), 1024 * 1024 * 16);
     PrintWriter pw = new PrintWriter(new BufferedOutputStream(new FileOutputStream(f2), 1024 * 1024 * 16));
     String line;
     while ((line = br.readLine()) != null) {
     int start = 0;
     Matcher m = pat.matcher(line);
     while (m.find()) {
     pw.print(line.substring(start, m.start()));
     start = m.end();
     if (!map.containsKey(m.group())) {
     map.put(m.group(), "irgendwas_" + index++);
     }
     pw.print(map.get(m.group()));
     }
     pw.println(line.substring(start));
     }
     pw.flush();
     pw.close();
     br.close();*/
}

}```[/spoiler]

Macht er zB so etwas:

[spoiler]```/*

To irgendwas_1 this irgendwas_2, irgendwas_3 irgendwas_4 | irgendwas_5
and open the irgendwas_2 in the irgendwas_6.
*/
package irgendwas_7;

import java.awt.irgendwas_8;
import java.io.irgendwas_9;
import java.io.irgendwas_10;
import java.io.irgendwas_11;
import java.io.irgendwas_12;
import java.io.irgendwas_13;
import java.util.irgendwas_14;
import java.util.irgendwas_15;
import java.util.irgendwas_16;
import java.util.Set;
import java.util.irgendwas_17;
import java.util.irgendwas_18.irgendwas_19;
import java.util.irgendwas_18.irgendwas_20;
import irgendwas_21.irgendwas_22.irgendwas_23;
import irgendwas_21.irgendwas_22.irgendwas_24;
import irgendwas_21.irgendwas_22.irgendwas_25;
import irgendwas_21.irgendwas_22.irgendwas_26;
import irgendwas_21.irgendwas_22.irgendwas_27;
import irgendwas_21.irgendwas_22.irgendwas_28.irgendwas_29;
import irgendwas_21.irgendwas_22.irgendwas_28.irgendwas_30;

/**
*
*/
public class Main {

private static irgendwas_31 irgendwas_32(irgendwas_31 str) {
    try {
        irgendwas_31[] keys = "abstract assert boolean break byte case catch char class const continue default do double else enum extends final finally float for if goto implements import instanceof int interface long native new package private protected public return short static strictfp super switch synchronized this throw throws transient try void volatile while".irgendwas_33(" ");
        irgendwas_14.sort(keys);
        irgendwas_15<irgendwas_31, irgendwas_31> map = new irgendwas_15<irgendwas_31, irgendwas_31>();
        for (irgendwas_31 irgendwas_34 : keys) {
            map.put(irgendwas_34, irgendwas_34);
        }
        int irgendwas_35 = 1;
        irgendwas_20 pat = irgendwas_20.irgendwas_36("\\w{5,}");
        irgendwas_9 br = new irgendwas_9(new irgendwas_12(str));
        irgendwas_13 sw = null;
        {
            int len = 16;
            while (len <= str.irgendwas_37()) {
                len <<= 1;
            }
            irgendwas_38.out.irgendwas_39("len = " + len);
            sw = new irgendwas_13(len);
        }
        irgendwas_11 pw = new irgendwas_11(sw);
        irgendwas_31 line;
        while ((line = br.irgendwas_40()) != null) {
            int irgendwas_41 = 0;
            irgendwas_19 m = pat.irgendwas_42(line);
            while (m.find()) {
                pw.irgendwas_43(line.irgendwas_44(irgendwas_41, m.irgendwas_41()));
                irgendwas_41 = m.end();
                if (!map.irgendwas_45(m.irgendwas_46())) {
                    map.put(m.irgendwas_46(), "irgendwas_47" + irgendwas_35++);
                }
                pw.irgendwas_43(map.get(m.irgendwas_46()));
            }
            pw.irgendwas_39(line.irgendwas_44(irgendwas_41));
        }
        pw.irgendwas_48();
        return sw.irgendwas_49();
    } catch (irgendwas_10 irgendwas_50) {
        //irgendwas_51
        return null;
    }
}

private static Set<irgendwas_31> irgendwas_52(irgendwas_31 str, int idx, Set<irgendwas_31> set) {
    int irgendwas_53 = idx + 1;
    if (irgendwas_53 >= str.irgendwas_37()) {
        if (!set.irgendwas_54(str)) {
            set.add(str);
            irgendwas_52(str, 0, set);
        }
    } else {
        irgendwas_52(str, irgendwas_53, set);
        irgendwas_52(str.irgendwas_44(0, idx) + str.irgendwas_55(irgendwas_53) + str.irgendwas_55(idx) + str.irgendwas_44(irgendwas_53 + 1), irgendwas_53, set);
    }
    return set;
}

/**
 * @irgendwas_56 args the irgendwas_57 line irgendwas_58
 */
public static void main(irgendwas_31[] args) throws irgendwas_10 {
    // TODO code irgendwas_59 irgendwas_60 here
    /*irgendwas_38.out.irgendwas_39(irgendwas_52("irgendwas_61", 0, new irgendwas_16<irgendwas_31>()));
     irgendwas_38.out.irgendwas_39(irgendwas_52("irgendwas_61", 0, new irgendwas_17<irgendwas_31>()));

     irgendwas_31[] keys = "abstract assert boolean break byte case catch char class const continue default do double else enum extends final finally float for if goto implements import instanceof int interface long native new package private protected public return short static strictfp super switch synchronized this throw throws transient try void volatile while".irgendwas_33(" ");
     irgendwas_14.sort(keys);
     irgendwas_15<irgendwas_31, irgendwas_31> map = new irgendwas_15<irgendwas_31, irgendwas_31>();
     for (irgendwas_31 irgendwas_34 : keys) {
     map.put(irgendwas_34, irgendwas_34);
     }
     int irgendwas_35 = 1;
     irgendwas_20 pat = irgendwas_20.irgendwas_36("\\w{5,}");
     /*irgendwas_62 jfc = new irgendwas_62();
     if (jfc.irgendwas_63(null) != irgendwas_62.irgendwas_64) {
     return;
     }
     File f1 = jfc.irgendwas_65();
     if (jfc.irgendwas_66(null) != irgendwas_62.irgendwas_64) {
     return;
     }
     File f2 = jfc.irgendwas_65();
     if (!f1.irgendwas_67() || !f1.irgendwas_68() || !f2.irgendwas_67() || !f2.irgendwas_69() || f1.irgendwas_70(f2)) {
     return;
     }*/
    irgendwas_23 jf = new irgendwas_23("irgendwas_71");
    jf.irgendwas_72(new irgendwas_8(1, 2));
    final irgendwas_25 jta1 = new irgendwas_25();
    final irgendwas_25 jta2 = new irgendwas_25();
    jf.add(new irgendwas_24(jta1));
    jf.add(new irgendwas_24(jta2));
    jta1.irgendwas_73().irgendwas_74(new irgendwas_30() {
        @irgendwas_75
        public void irgendwas_76(irgendwas_29 e) {
            irgendwas_26.irgendwas_77(new irgendwas_78() {
                @irgendwas_75
                public void run() {
                    jta2.irgendwas_79(irgendwas_32(jta1.irgendwas_80()));
                }
            });
        }

        @irgendwas_75
        public void irgendwas_81(irgendwas_29 e) {
            irgendwas_26.irgendwas_77(new irgendwas_78() {
                @irgendwas_75
                public void run() {
                    jta2.irgendwas_79(irgendwas_32(jta1.irgendwas_80()));
                }
            });
        }

        @irgendwas_75
        public void irgendwas_82(irgendwas_29 e) {
            irgendwas_26.irgendwas_77(new irgendwas_78() {
                @irgendwas_75
                public void run() {
                    jta2.irgendwas_79(irgendwas_32(jta1.irgendwas_80()));
                }
            });
        }
    });
    jf.pack();
    jf.irgendwas_83(720, 540);
    jf.irgendwas_84(irgendwas_27.irgendwas_85);
    jf.irgendwas_86(true);
    /*irgendwas_9 br = new irgendwas_9(new irgendwas_87(f1), 1024 * 1024 * 16);
     irgendwas_11 pw = new irgendwas_11(new irgendwas_88(new irgendwas_89(f2), 1024 * 1024 * 16));
     irgendwas_31 line;
     while ((line = br.irgendwas_40()) != null) {
     int irgendwas_41 = 0;
     irgendwas_19 m = pat.irgendwas_42(line);
     while (m.find()) {
     pw.irgendwas_43(line.irgendwas_44(irgendwas_41, m.irgendwas_41()));
     irgendwas_41 = m.end();
     if (!map.irgendwas_45(m.irgendwas_46())) {
     map.put(m.irgendwas_46(), "irgendwas_47" + irgendwas_35++);
     }
     pw.irgendwas_43(map.get(m.irgendwas_46()));
     }
     pw.irgendwas_39(line.irgendwas_44(irgendwas_41));
     }
     pw.irgendwas_48();
     pw.irgendwas_90();
     br.irgendwas_90();*/
}

}```[/spoiler]

Ich hatte bisher/zunächst mit .java-Dateien (source code) gearbeitet, aber mit jta und copy ‚n‘ paste ist das viel angenehmer. Um die GUI nicht aufzublähen, hab ich mich also für new DocumentListener() entschieden, der bekommt alles mit (DocumentEvent: getOffset() und getLength()).

Um damit Anfänger zu ärgern.

Firephoenix · 25. Juli 2014 um 06:12

import java.awt.irgendwas_8;

:suspect:

SlaterB · 25. Juli 2014 um 06:19

ab Java 9