Advertisement
Guest User

Untitled

a guest
Nov 28th, 2014
164
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 6.23 KB | None | 0 0
  1. /**
  2.  * My texteditor can open, close, clear, save, and save as.
  3.  *
  4.  * @author Henning Scharf
  5.  */
  6.  
  7. import java.io.BufferedReader;
  8. import java.io.File;
  9. import java.io.FileNotFoundException;
  10. import java.io.FileReader;
  11. import java.io.FileWriter;
  12. import java.io.IOException;
  13.  
  14. import javafx.application.Application;
  15. import javafx.application.Platform;
  16. import javafx.event.ActionEvent;
  17. import javafx.event.EventHandler;
  18. import javafx.scene.Scene;
  19. import javafx.scene.control.Menu;
  20. import javafx.scene.control.MenuBar;
  21. import javafx.scene.control.MenuItem;
  22. import javafx.scene.control.TextArea;
  23. import javafx.scene.layout.Priority;
  24. import javafx.scene.layout.VBox;
  25. import javafx.stage.FileChooser;
  26. import javafx.stage.Stage;
  27.  
  28. public class TextEditor extends Application {
  29.     // saves the path of my working file
  30.     private static String lastSaved;
  31.  
  32.     public static void main(String[] args) {
  33.         Application.launch(args);
  34.     }
  35.  
  36.     @Override
  37.     public void start(Stage primaryStage) throws Exception {
  38.         primaryStage.setTitle("TextEditor");
  39.         VBox vbox = new VBox(1.0);
  40.         // 1 textarea
  41.         TextArea txt = new TextArea("");
  42.         // 1 Menubar
  43.         final MenuBar menubar = new MenuBar();
  44.         // I thought about only using 1 "File" because other programs handle it
  45.         // similar
  46.         Menu menuFile = new Menu("Datei");
  47.         menubar.getMenus().addAll(menuFile);
  48.  
  49.         // Here i add my Menu Items
  50.         MenuItem menuOpen1 = new MenuItem("Neu");
  51.         MenuItem menuOpen2 = new MenuItem("Öffnen");
  52.         MenuItem menuOpen3 = new MenuItem("Speichern");
  53.         MenuItem menuOpen4 = new MenuItem("Speichern unter");
  54.         MenuItem menuOpen5 = new MenuItem("Schließen");
  55.  
  56.         // now i add my items to "Datei"
  57.         menuFile.getItems().addAll(menuOpen1, menuOpen2, menuOpen3, menuOpen4,
  58.                 menuOpen5);
  59.         // this one resets my textarea
  60.         menuOpen1.setOnAction(new EventHandler<ActionEvent>() {
  61.  
  62.             @Override
  63.             public void handle(ActionEvent arg0) {
  64.                 txt.clear();
  65.                 lastSaved = null;
  66.  
  67.             }
  68.         });
  69.        
  70.         //open
  71.         menuOpen2.setOnAction(new EventHandler<ActionEvent>() {
  72.  
  73.             @Override
  74.             public void handle(ActionEvent arg0) {
  75.                 txt.clear();
  76.                 FileChooser fchoose = new FileChooser();
  77.                 fchoose.setTitle("Open Menu");
  78.                 fchoose.setSelectedExtensionFilter(new FileChooser.ExtensionFilter(
  79.                         "*.txt", "*.log", "*.txt", "*.log"));
  80.                 File choosenFile = fchoose.showOpenDialog(primaryStage);
  81.  
  82.                 if (choosenFile != null) {
  83.                     try {
  84.                         // read my text
  85.                         BufferedReader reader = new BufferedReader(
  86.                                 new FileReader(choosenFile));
  87.                         // puffer string
  88.                         String puffer;
  89.                         try {
  90.                             while ((puffer = reader.readLine()) != null) {
  91.                                 // add text and enters
  92.                                 txt.appendText(puffer);
  93.                                 txt.appendText(System.lineSeparator());
  94.                             }
  95.  
  96.                         } catch (IOException e) {
  97.                             e.printStackTrace();
  98.                         }
  99.                     } catch (FileNotFoundException e) {
  100.                         e.printStackTrace();
  101.                     }
  102.  
  103.                 }
  104.                 // set my working file
  105.                 lastSaved = choosenFile.getAbsolutePath();
  106.             }
  107.         });
  108.         //save
  109.         menuOpen3.setOnAction(new EventHandler<ActionEvent>() {
  110.  
  111.             @Override
  112.             public void handle(ActionEvent arg0) {
  113.                 // check if this is the first file used in this instance
  114.                 if (lastSaved != null) {
  115.  
  116.                     FileWriter fWriter = null;
  117.  
  118.                     try {
  119.                         // write my text in my file
  120.                         fWriter = new FileWriter(lastSaved);
  121.                         fWriter.write(txt.getText());
  122.  
  123.                     } catch (IOException e) {
  124.                         e.printStackTrace();
  125.                     } finally {
  126.                         try {
  127.                             // cant write without closing
  128.                             fWriter.close();
  129.                         } catch (IOException e) {
  130.                             e.printStackTrace();
  131.                         }
  132.                     }
  133.                     // use save as if it is the first one
  134.                 } else {
  135.                     FileChooser fchoose = new FileChooser();
  136.                     fchoose.setTitle("Save as Menu");
  137.                     // setting file endings
  138.                     fchoose.setSelectedExtensionFilter(new FileChooser.ExtensionFilter(
  139.                             "*.txt", "*.log", "*.txt", "*.log"));
  140.                     // show file
  141.                     File choosenFile = fchoose.showSaveDialog(primaryStage);
  142.  
  143.                     FileWriter fWriter = null;
  144.                     // checks if i have a txt ending already
  145.                     if (choosenFile != null
  146.                             && !choosenFile.getName().contains(".txt")) {
  147.                         choosenFile = new File(choosenFile + ".txt");
  148.                     }
  149.  
  150.                     try {
  151.                         // if i have no working path so i will "save as"
  152.                         fWriter = new FileWriter(choosenFile);
  153.  
  154.                         // writes
  155.                         fWriter.write(txt.getText());
  156.                         fWriter.flush();
  157.  
  158.                     } catch (IOException e) {
  159.                         e.printStackTrace();
  160.                     } finally {
  161.                         try {
  162.                             // cant write without closing
  163.                             fWriter.close();
  164.                         } catch (IOException e) {
  165.                             e.printStackTrace();
  166.                         }
  167.                     }
  168.  
  169.                     lastSaved = choosenFile.getAbsolutePath();
  170.  
  171.                 }
  172.  
  173.             }
  174.         });
  175.        
  176.         //save as
  177.         menuOpen4.setOnAction(new EventHandler<ActionEvent>() {
  178.  
  179.             @Override
  180.             public void handle(ActionEvent arg0) {
  181.                 FileChooser fchoose = new FileChooser();
  182.                 fchoose.setTitle("Save as Menu");
  183.                 // file endings
  184.                 fchoose.setSelectedExtensionFilter(new FileChooser.ExtensionFilter(
  185.                         "*.txt", "*.log", "*.txt", "*.log"));
  186.                 // show file
  187.                 File choosenFile = fchoose.showSaveDialog(primaryStage);
  188.  
  189.                 FileWriter fWriter = null;
  190.                 // checks if i have a txt ending already
  191.                 if (choosenFile != null
  192.                         && !choosenFile.getName().endsWith(".txt")) {
  193.                     choosenFile = new File(choosenFile.getName() + ".txt");
  194.                 }
  195.  
  196.                 try {
  197.  
  198.                     fWriter = new FileWriter(choosenFile);
  199.  
  200.                     // write my text in my file
  201.                     fWriter.write(txt.getText());
  202.  
  203.                 } catch (IOException e) {
  204.                     e.printStackTrace();
  205.                 } finally {
  206.                     try {
  207.  
  208.                         fWriter.close();
  209.  
  210.                     } catch (IOException e) {
  211.                         e.printStackTrace();
  212.                     }
  213.                 }
  214.                 // sets working path
  215.                 lastSaved = choosenFile.getAbsolutePath();
  216.  
  217.             }
  218.  
  219.         });
  220.         // this one closes my Stage
  221.         menuOpen5.setOnAction(new EventHandler<ActionEvent>() {
  222.  
  223.             @Override
  224.             public void handle(ActionEvent arg0) {
  225.                 primaryStage.close();
  226.                 Platform.exit();
  227.  
  228.             }
  229.         });
  230.  
  231.         // here i let my textarea grow with my window
  232.         VBox.setVgrow(txt, Priority.ALWAYS);
  233.         // this one adds everything to my box
  234.         vbox.getChildren().addAll(menubar, txt);
  235.         // this shows my box
  236.         Scene scene = new Scene(vbox);
  237.         primaryStage.setScene(scene);
  238.         primaryStage.show();
  239.     }
  240.  
  241. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement