Notepad


1   /*
2    * @(#)Notepad.java 1.31 05/11/17
3    * 
4    * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
5    * 
6    * Redistribution and use in source and binary forms, with or without
7    * modification, are permitted provided that the following conditions are met:
8    * 
9    * -Redistribution of source code must retain the above copyright notice, this
10   *  list of conditions and the following disclaimer.
11   * 
12   * -Redistribution in binary form must reproduce the above copyright notice, 
13   *  this list of conditions and the following disclaimer in the documentation
14   *  and/or other materials provided with the distribution.
15   * 
16   * Neither the name of Sun Microsystems, Inc. or the names of contributors may 
17   * be used to endorse or promote products derived from this software without 
18   * specific prior written permission.
19   * 
20   * This software is provided "AS IS," without a warranty of any kind. ALL 
21   * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
22   * ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
23   * OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MIDROSYSTEMS, INC. ("SUN")
24   * AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE
25   * AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
26   * DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST 
27   * REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, 
28   * INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY 
29   * OF LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, 
30   * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
31   * 
32   * You acknowledge that this software is not designed, licensed or intended
33   * for use in the design, construction, operation or maintenance of any
34   * nuclear facility.
35   */
36  
37  /*
38   * @(#)Notepad.java 1.31 05/11/17
39   */
40  
41  import java.awt.*;
42  import java.awt.event.*;
43  import java.beans.*;
44  import java.io.*;
45  import java.net.URL  ;
46  import java.util.*;
47  
48  import javax.swing.text.*;
49  import javax.swing.undo.*;
50  import javax.swing.event.*;
51  import javax.swing.*;
52  
53  /**
54   * Sample application using the simple text editor component that
55   * supports only one font.
56   *
57   * @author  Timothy Prinzing
58   * @version 1.31 11/17/05 
59   */
60  class Notepad extends JPanel {
61  
62      private static ResourceBundle resources;
63      private final static String   EXIT_AFTER_PAINT = new String  ("-exit");
64      private static boolean exitAfterFirstPaint;
65  
66      static {
67          try {
68              resources = ResourceBundle.getBundle("resources.Notepad", 
69                                                   Locale.getDefault());
70          } catch (MissingResourceException mre) {
71              System.err.println("resources/Notepad.properties not found");
72              System.exit(1);
73          }
74      }
75  
76      public void paintChildren(Graphics g) {
77          super.paintChildren(g);
78          if (exitAfterFirstPaint) {
79              System.exit(0);
80          }
81      }
82  
83      Notepad() {
84      super(true);
85  
86      // Force SwingSet to come up in the Cross Platform L&F
87      try {
88          UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
89          // If you want the System L&F instead, comment out the above line and
90          // uncomment the following:
91          // UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
92      } catch (Exception   exc) {
93          System.err.println("Error loading L&F: " + exc);
94      }
95  
96      setBorder(BorderFactory.createEtchedBorder());
97      setLayout(new BorderLayout());
98  
99      // create the embedded JTextComponent
100     editor = createEditor();
101     // Add this as a listener for undoable edits.
102     editor.getDocument().addUndoableEditListener(undoHandler);
103 
104     // install the command table
105     commands = new Hashtable();
106     Action[] actions = getActions();
107     for (int i = 0; i < actions.length; i++) {
108         Action a = actions[i];
109         //commands.put(a.getText(Action.NAME), a);
110         commands.put(a.getValue(Action.NAME), a);
111     }
112     
113     JScrollPane scroller = new JScrollPane();
114     JViewport port = scroller.getViewport();
115     port.add(editor);
116     try {
117         String   vpFlag = resources.getString("ViewportBackingStore");
118         Boolean   bs = Boolean.valueOf(vpFlag);
119         port.setBackingStoreEnabled(bs.booleanValue());
120     } catch (MissingResourceException mre) {
121         // just use the viewport default
122     }
123 
124     menuItems = new Hashtable();
125     JPanel panel = new JPanel();
126     panel.setLayout(new BorderLayout());    
127     panel.add("North",createToolbar());
128     panel.add("Center", scroller);
129     add("Center", panel);
130     add("South", createStatusbar());
131     }
132 
133     public static void main(String  [] args) {
134         try {
135         String   vers = System.getProperty("java.version");
136         if (vers.compareTo("1.1.2") < 0) {
137             System.out.println("!!!WARNING: Swing must be run with a " +
138                                "1.1.2 or higher version VM!!!");
139         }
140         if (args.length > 0 && args[0].equals(EXIT_AFTER_PAINT)) {
141             exitAfterFirstPaint = true;
142         }
143         JFrame frame = new JFrame();
144         frame.setTitle(resources.getString("Title"));
145     frame.setBackground(Color.lightGray);
146     frame.getContentPane().setLayout(new BorderLayout());
147         Notepad notepad = new Notepad();
148     frame.getContentPane().add("Center", notepad);
149         frame.setJMenuBar(notepad.createMenubar());
150     frame.addWindowListener(new AppCloser());
151     frame.pack();
152     frame.setSize(500, 600);
153         frame.show();
154         } catch (Throwable   t) {
155             System.out.println("uncaught exception: " + t);
156             t.printStackTrace();
157         }
158     }
159 
160     /**
161      * Fetch the list of actions supported by this
162      * editor.  It is implemented to return the list
163      * of actions supported by the embedded JTextComponent
164      * augmented with the actions defined locally.
165      */
166     public Action[] getActions() {
167     return TextAction.augmentList(editor.getActions(), defaultActions);
168     }
169 
170     /**
171      * Create an editor to represent the given document.  
172      */
173     protected JTextComponent createEditor() {
174     JTextComponent c = new JTextArea();
175     c.setDragEnabled(true);
176     c.setFont(new Font("monospaced", Font.PLAIN, 12));
177     return c;
178     }
179 
180     /** 
181      * Fetch the editor contained in this panel
182      */
183     protected JTextComponent getEditor() {
184     return editor;
185     }
186 
187     /**
188      * To shutdown when run as an application.  This is a
189      * fairly lame implementation.   A more self-respecting
190      * implementation would at least check to see if a save
191      * was needed.
192      */
193     protected static final class AppCloser extends WindowAdapter {
194         public void windowClosing(WindowEvent e) {
195         System.exit(0);
196     }
197     }
198 
199     /**
200      * Find the hosting frame, for the file-chooser dialog.
201      */
202     protected Frame getFrame() {
203     for (Container p = getParent(); p != null; p = p.getParent()) {
204         if (p instanceof Frame) {
205         return (Frame) p;
206         }
207     }
208     return null;
209     }
210 
211     /**
212      * This is the hook through which all menu items are
213      * created.  It registers the result with the menuitem
214      * hashtable so that it can be fetched with getMenuItem().
215      * @see #getMenuItem
216      */
217     protected JMenuItem createMenuItem(String   cmd) {
218     JMenuItem mi = new JMenuItem(getResourceString(cmd + labelSuffix));
219         URL   url = getResource(cmd + imageSuffix);
220     if (url != null) {
221         mi.setHorizontalTextPosition(JButton.RIGHT);
222         mi.setIcon(new ImageIcon(url));
223     }
224     String   astr = getResourceString(cmd + actionSuffix);
225     if (astr == null) {
226         astr = cmd;
227     }
228     mi.setActionCommand(astr);
229     Action a = getAction(astr);
230     if (a != null) {
231         mi.addActionListener(a);
232         a.addPropertyChangeListener(createActionChangeListener(mi));
233         mi.setEnabled(a.isEnabled());
234     } else {
235         mi.setEnabled(false);
236     }
237     menuItems.put(cmd, mi);
238     return mi;
239     }
240 
241     /**
242      * Fetch the menu item that was created for the given
243      * command.
244      * @param cmd  Name of the action.
245      * @returns item created for the given command or null
246      *  if one wasn't created.
247      */
248     protected JMenuItem getMenuItem(String   cmd) {
249     return (JMenuItem) menuItems.get(cmd);
250     }
251 
252     protected Action getAction(String   cmd) {
253     return (Action) commands.get(cmd);
254     }
255 
256     protected String   getResourceString(String   nm) {
257     String   str;
258     try {
259         str = resources.getString(nm);
260     } catch (MissingResourceException mre) {
261         str = null;
262     }
263     return str;
264     }
265 
266     protected URL   getResource(String   key) {
267     String   name = getResourceString(key);
268     if (name != null) {
269         URL   url = this.getClass().getResource(name);
270         return url;
271     }
272     return null;
273     }
274 
275     protected Container getToolbar() {
276     return toolbar;
277     }
278 
279     protected JMenuBar getMenubar() {
280     return menubar;
281     }
282 
283     /**
284      * Create a status bar
285      */
286     protected Component createStatusbar() {
287     // need to do something reasonable here
288     status = new StatusBar();
289     return status;
290     }
291 
292     /**
293      * Resets the undo manager.
294      */
295     protected void resetUndoManager() {
296     undo.discardAllEdits();
297     undoAction.update();
298     redoAction.update();
299     }
300 
301     /**
302      * Create the toolbar.  By default this reads the 
303      * resource file for the definition of the toolbar.
304      */
305     private Component createToolbar() {
306     toolbar = new JToolBar();
307     String  [] toolKeys = tokenize(getResourceString("toolbar"));
308     for (int i = 0; i < toolKeys.length; i++) {
309         if (toolKeys[i].equals("-")) {
310         toolbar.add(Box.createHorizontalStrut(5));
311         } else {
312         toolbar.add(createTool(toolKeys[i]));
313         }
314     }
315     toolbar.add(Box.createHorizontalGlue());
316     return toolbar;
317     }
318 
319     /**
320      * Hook through which every toolbar item is created.
321      */
322     protected Component createTool(String   key) {
323     return createToolbarButton(key);
324     }
325 
326     /**
327      * Create a button to go inside of the toolbar.  By default this
328      * will load an image resource.  The image filename is relative to
329      * the classpath (including the '.' directory if its a part of the
330      * classpath), and may either be in a JAR file or a separate file.
331      * 
332      * @param key The key in the resource file to serve as the basis
333      *  of lookups.
334      */
335     protected JButton createToolbarButton(String   key) {
336     URL   url = getResource(key + imageSuffix);
337         JButton b = new JButton(new ImageIcon(url)) {
338             public float getAlignmentY() { return 0.5f; }
339     };
340         b.setRequestFocusEnabled(false);
341         b.setMargin(new Insets(1,1,1,1));
342 
343     String   astr = getResourceString(key + actionSuffix);
344     if (astr == null) {
345         astr = key;
346     }
347     Action a = getAction(astr);
348     if (a != null) {
349         b.setActionCommand(astr);
350         b.addActionListener(a);
351     } else {
352         b.setEnabled(false);
353     }
354 
355     String   tip = getResourceString(key + tipSuffix);
356     if (tip != null) {
357         b.setToolTipText(tip);
358     }
359  
360         return b;
361     }
362 
363     /**
364      * Take the given string and chop it up into a series
365      * of strings on whitespace boundaries.  This is useful
366      * for trying to get an array of strings out of the
367      * resource file.
368      */
369     protected String  [] tokenize(String   input) {
370     Vector v = new Vector();
371     StringTokenizer t = new StringTokenizer(input);
372     String   cmd[];
373 
374     while (t.hasMoreTokens())
375         v.addElement(t.nextToken());
376     cmd = new String  [v.size()];
377     for (int i = 0; i < cmd.length; i++)
378         cmd[i] = (String  ) v.elementAt(i);
379 
380     return cmd;
381     }
382 
383     /**
384      * Create the menubar for the app.  By default this pulls the
385      * definition of the menu from the associated resource file. 
386      */
387     protected JMenuBar createMenubar() {
388     JMenuItem mi;
389     JMenuBar mb = new JMenuBar();
390 
391     String  [] menuKeys = tokenize(getResourceString("menubar"));
392     for (int i = 0; i < menuKeys.length; i++) {
393         JMenu m = createMenu(menuKeys[i]);
394         if (m != null) {
395         mb.add(m);
396         }
397     }
398         this.menubar = mb;
399     return mb;
400     }
401 
402     /**
403      * Create a menu for the app.  By default this pulls the
404      * definition of the menu from the associated resource file.
405      */
406     protected JMenu createMenu(String   key) {
407     String  [] itemKeys = tokenize(getResourceString(key));
408     JMenu menu = new JMenu(getResourceString(key + "Label"));
409     for (int i = 0; i < itemKeys.length; i++) {
410         if (itemKeys[i].equals("-")) {
411         menu.addSeparator();
412         } else {
413         JMenuItem mi = createMenuItem(itemKeys[i]);
414         menu.add(mi);
415         }
416     }
417     return menu;
418     }
419 
420     // Yarked from JMenu, ideally this would be public.
421     protected PropertyChangeListener createActionChangeListener(JMenuItem b) {
422     return new ActionChangedListener(b);
423     }
424 
425     // Yarked from JMenu, ideally this would be public.
426     private class ActionChangedListener implements PropertyChangeListener {
427         JMenuItem menuItem;
428         
429         ActionChangedListener(JMenuItem mi) {
430             super();
431             this.menuItem = mi;
432         }
433         public void propertyChange(PropertyChangeEvent e) {
434             String   propertyName = e.getPropertyName();
435             if (e.getPropertyName().equals(Action.NAME)) {
436                 String   text = (String  ) e.getNewValue();
437                 menuItem.setText(text);
438             } else if (propertyName.equals("enabled")) {
439                 Boolean   enabledState = (Boolean  ) e.getNewValue();
440                 menuItem.setEnabled(enabledState.booleanValue());
441             }
442         }
443     }
444 
445     private JTextComponent editor;
446     private Hashtable commands;
447     private Hashtable menuItems;
448     private JMenuBar menubar;
449     private JToolBar toolbar;
450     private JComponent status;
451     private JFrame elementTreeFrame;
452     protected ElementTreePanel elementTreePanel;
453 
454     protected FileDialog fileDialog;
455 
456     /**
457      * Listener for the edits on the current document.
458      */
459     protected UndoableEditListener undoHandler = new UndoHandler();
460 
461     /** UndoManager that we add edits to. */
462     protected UndoManager undo = new UndoManager();
463 
464     /**
465      * Suffix applied to the key used in resource file
466      * lookups for an image.
467      */
468     public static final String   imageSuffix = "Image";
469 
470     /**
471      * Suffix applied to the key used in resource file
472      * lookups for a label.
473      */
474     public static final String   labelSuffix = "Label";
475 
476     /**
477      * Suffix applied to the key used in resource file
478      * lookups for an action.
479      */
480     public static final String   actionSuffix = "Action";
481 
482     /**
483      * Suffix applied to the key used in resource file
484      * lookups for tooltip text.
485      */
486     public static final String   tipSuffix = "Tooltip";
487 
488     public static final String   openAction = "open";
489     public static final String   newAction  = "new";
490     public static final String   saveAction = "save";
491     public static final String   exitAction = "exit";
492     public static final String   showElementTreeAction = "showElementTree";
493 
494     class UndoHandler implements UndoableEditListener {
495 
496     /**
497      * Messaged when the Document has created an edit, the edit is
498      * added to <code>undo</code>, an instance of UndoManager.
499      */
500         public void undoableEditHappened(UndoableEditEvent e) {
501         undo.addEdit(e.getEdit());
502         undoAction.update();
503         redoAction.update();
504     }
505     }
506 
507     /**
508      * FIXME - I'm not very useful yet
509      */
510     class StatusBar extends JComponent {
511 
512         public StatusBar() {
513         super();
514         setLayout(new BoxLayout(this, BoxLayout.X_AXIS));
515     }
516 
517         public void paint(Graphics g) {
518         super.paint(g);
519     }
520 
521     }
522 
523     // --- action implementations -----------------------------------
524 
525     private UndoAction undoAction = new UndoAction();
526     private RedoAction redoAction = new RedoAction();
527 
528     /**
529      * Actions defined by the Notepad class
530      */
531     private Action[] defaultActions = {
532     new NewAction(),
533     new OpenAction(),
534         new SaveAction(),
535     new ExitAction(),
536     new ShowElementTreeAction(),
537         undoAction,
538         redoAction
539     };
540 
541     class UndoAction extends AbstractAction {
542     public UndoAction() {
543         super("Undo");
544         setEnabled(false);
545     }
546 
547     public void actionPerformed(ActionEvent e) {
548         try {
549         undo.undo();
550         } catch (CannotUndoException ex) {
551         System.out.println("Unable to undo: " + ex);
552         ex.printStackTrace();
553         }
554         update();
555         redoAction.update();
556     }
557 
558     protected void update() {
559         if(undo.canUndo()) {
560         setEnabled(true);
561         putValue(Action.NAME, undo.getUndoPresentationName());
562         }
563         else {
564         setEnabled(false);
565         putValue(Action.NAME, "Undo");
566         }
567     }
568     }
569 
570     class RedoAction extends AbstractAction {
571     public RedoAction() {
572         super("Redo");
573         setEnabled(false);
574     }
575 
576     public void actionPerformed(ActionEvent e) {
577         try {
578         undo.redo();
579         } catch (CannotRedoException ex) {
580         System.out.println("Unable to redo: " + ex);
581         ex.printStackTrace();
582         }
583         update();
584         undoAction.update();
585     }
586 
587     protected void update() {
588         if(undo.canRedo()) {
589         setEnabled(true);
590         putValue(Action.NAME, undo.getRedoPresentationName());
591         }
592         else {
593         setEnabled(false);
594         putValue(Action.NAME, "Redo");
595         }
596     }
597     }
598 
599     class OpenAction extends NewAction {
600 
601     OpenAction() {
602         super(openAction);
603     }
604 
605         public void actionPerformed(ActionEvent e) {
606         Frame frame = getFrame();
607             JFileChooser chooser = new JFileChooser();
608             int ret = chooser.showOpenDialog(frame);
609 
610             if (ret != JFileChooser.APPROVE_OPTION) {
611         return;
612         }
613 
614             File f = chooser.getSelectedFile();
615         if (f.isFile() && f.canRead()) {
616         Document oldDoc = getEditor().getDocument();
617         if(oldDoc != null)
618             oldDoc.removeUndoableEditListener(undoHandler);
619         if (elementTreePanel != null) {
620             elementTreePanel.setEditor(null);
621         }
622         getEditor().setDocument(new PlainDocument());
623                 frame.setTitle(f.getName());
624         Thread   loader = new FileLoader(f, editor.getDocument());
625         loader.start();
626         } else {
627                 JOptionPane.showMessageDialog(getFrame(),
628                         "Could not open file: " + f,
629                         "Error opening file",
630                         JOptionPane.ERROR_MESSAGE);
631         }
632     }
633     }
634     
635     class SaveAction extends AbstractAction {
636 
637     SaveAction() {
638         super(saveAction);
639     }
640 
641         public void actionPerformed(ActionEvent e) {
642             Frame frame = getFrame();
643             JFileChooser chooser = new JFileChooser();
644             int ret = chooser.showSaveDialog(frame);
645 
646             if (ret != JFileChooser.APPROVE_OPTION) {
647                 return;
648             }
649 
650             File f = chooser.getSelectedFile();
651             frame.setTitle(f.getName());
652             Thread   saver = new FileSaver(f, editor.getDocument());
653             saver.start();
654     }
655     }
656 
657     class NewAction extends AbstractAction {
658 
659     NewAction() {
660         super(newAction);
661     }
662 
663     NewAction(String   nm) {
664         super(nm);
665     }
666 
667         public void actionPerformed(ActionEvent e) {
668         Document oldDoc = getEditor().getDocument();
669         if(oldDoc != null)
670         oldDoc.removeUndoableEditListener(undoHandler);
671         getEditor().setDocument(new PlainDocument());
672         getEditor().getDocument().addUndoableEditListener(undoHandler);
673         resetUndoManager();
674             getFrame().setTitle(resources.getString("Title"));
675         revalidate();
676     }
677     }
678 
679     /**
680      * Really lame implementation of an exit command
681      */
682     class ExitAction extends AbstractAction {
683 
684     ExitAction() {
685         super(exitAction);
686     }
687 
688         public void actionPerformed(ActionEvent e) {
689         System.exit(0);
690     }
691     }
692 
693     /**
694      * Action that brings up a JFrame with a JTree showing the structure
695      * of the document.
696      */
697     class ShowElementTreeAction extends AbstractAction {
698 
699     ShowElementTreeAction() {
700         super(showElementTreeAction);
701     }
702 
703     ShowElementTreeAction(String   nm) {
704         super(nm);
705     }
706 
707         public void actionPerformed(ActionEvent e) {
708         if(elementTreeFrame == null) {
709         // Create a frame containing an instance of 
710         // ElementTreePanel.
711         try {
712             String      title = resources.getString
713                             ("ElementTreeFrameTitle");
714             elementTreeFrame = new JFrame(title);
715         } catch (MissingResourceException mre) {
716             elementTreeFrame = new JFrame();
717         }
718 
719         elementTreeFrame.addWindowListener(new WindowAdapter() {
720             public void windowClosing(WindowEvent weeee) {
721             elementTreeFrame.setVisible(false);
722             }
723         });
724         Container fContentPane = elementTreeFrame.getContentPane();
725 
726         fContentPane.setLayout(new BorderLayout());
727         elementTreePanel = new ElementTreePanel(getEditor());
728         fContentPane.add(elementTreePanel);
729         elementTreeFrame.pack();
730         }
731         elementTreeFrame.show();
732     }
733     }
734 
735     /**
736      * Thread to load a file into the text storage model
737      */
738     class FileLoader extends Thread   {
739 
740     FileLoader(File f, Document doc) {
741         setPriority(4);
742         this.f = f;
743         this.doc = doc;
744     }
745 
746         public void run() {
747         try {
748         // initialize the statusbar
749         status.removeAll();
750         JProgressBar progress = new JProgressBar();
751         progress.setMinimum(0);
752         progress.setMaximum((int) f.length());
753         status.add(progress);
754         status.revalidate();
755 
756         // try to start reading
757         Reader in = new FileReader(f);
758         char[] buff = new char[4096];
759         int nch;
760         while ((nch = in.read(buff, 0, buff.length)) != -1) {
761             doc.insertString(doc.getLength(), new String  (buff, 0, nch), null);
762             progress.setValue(progress.getValue() + nch);
763         }
764         }
765         catch (IOException e) {
766                 final String   msg = e.getMessage();
767                 SwingUtilities.invokeLater(new Runnable  () {
768                     public void run() {
769                         JOptionPane.showMessageDialog(getFrame(),
770                                 "Could not open file: " + msg,
771                                 "Error opening file",
772                                 JOptionPane.ERROR_MESSAGE);
773         }
774                 });
775             }
776         catch (BadLocationException e) {
777         System.err.println(e.getMessage());
778         }
779             doc.addUndoableEditListener(undoHandler);
780             // we are done... get rid of progressbar
781             status.removeAll();
782             status.revalidate();
783 
784             resetUndoManager();
785 
786         if (elementTreePanel != null) {
787         SwingUtilities.invokeLater(new Runnable  () {
788             public void run() {
789             elementTreePanel.setEditor(getEditor());
790             }
791         });
792         }
793     }
794 
795     Document doc;
796     File f;
797     }
798 
799     /**
800      * Thread to save a document to file
801      */
802     class FileSaver extends Thread   {
803         Document doc;
804         File f;
805 
806     FileSaver(File f, Document doc) {
807         setPriority(4);
808         this.f = f;
809         this.doc = doc;
810     }
811 
812         public void run() {
813         try {
814         // initialize the statusbar
815         status.removeAll();
816         JProgressBar progress = new JProgressBar();
817         progress.setMinimum(0);
818         progress.setMaximum((int) doc.getLength());
819         status.add(progress);
820         status.revalidate();
821 
822         // start writing
823         Writer out = new FileWriter(f);
824                 Segment text = new Segment();
825                 text.setPartialReturn(true);
826                 int charsLeft = doc.getLength();
827         int offset = 0;
828                 while (charsLeft > 0) {
829                     doc.getText(offset, Math.min(4096, charsLeft), text);
830                     out.write(text.array, text.offset, text.count);
831                     charsLeft -= text.count;
832                     offset += text.count;
833                     progress.setValue(offset);
834                     try {
835                         Thread.sleep(10);
836                     } catch (InterruptedException   e) {
837                         e.printStackTrace();
838                     }
839                 }
840                 out.flush();
841                 out.close();
842         }
843         catch (IOException e) {
844                 final String   msg = e.getMessage();
845                 SwingUtilities.invokeLater(new Runnable  () {
846                     public void run() {
847                         JOptionPane.showMessageDialog(getFrame(),
848                                 "Could not save file: " + msg,
849                                 "Error saving file",
850                                 JOptionPane.ERROR_MESSAGE);
851         }
852                 });
853         }
854         catch (BadLocationException e) {
855         System.err.println(e.getMessage());
856         }
857             // we are done... get rid of progressbar
858             status.removeAll();
859             status.revalidate();
860     }
861     }
862 }
863
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags