Java实现记事本功能

 import java.awt.*;
 import java.awt.event.*;
 import java.text.*;
 import java.util.*;
 import java.io.*;
 import javax.swing.undo.*;
 import javax.swing.border.*;
 import javax.swing.*;
 import javax.swing.text.*;
 import javax.swing.event.*;
import java.awt.datatransfer.*;


public class notepad extends jframe implements actionlistener,documentlistener
{ //菜单
 jmenu filemenu,editmenu,formatmenu,viewmenu,helpmenu;
 //右键弹出菜单项
 jpopupmenu popupmenu;
 jmenuitem popupmenu_undo,popupmenu_cut,popupmenu_copy,popupmenu_paste,popupmenu_delete,popupmenu_selectall;
 //“文件”的菜单项
 jmenuitem filemenu_new,filemenu_open,filemenu_save,filemenu_saveas,filemenu_pagesetup,filemenu_print,filemenu_exit;
 //“编辑”的菜单项
 jmenuitem editmenu_undo,editmenu_cut,editmenu_copy,editmenu_paste,editmenu_delete,editmenu_find,editmenu_findnext,editmenu_replace,editmenu_goto,editmenu_selectall,editmenu_timedate;
 //“格式”的菜单项
 jcheckboxmenuitem formatmenu_linewrap;
 jmenuitem formatmenu_font;
 //“查看”的菜单项
 jcheckboxmenuitem viewmenu_status;
 //“帮助”的菜单项
 jmenuitem helpmenu_helptopics,helpmenu_aboutnotepad;
 //“文本”编辑区域
 jtextarea editarea;
 //状态栏标签
 jlabel statuslabel;
 //系统剪贴板
 toolkit toolkit=toolkit.getdefaulttoolkit();
 clipboard clipboard=toolkit.getsystemclipboard();
 //创建撤销操作管理器(与撤销操作有关)
 protected undomanager undo=new undomanager();
 protected undoableeditlistener undohandler=new undohandler();
 //其他变量
 string oldvalue;//存放编辑区原来的内容，用于比较文本是否有改动
 boolean isnewfile=true;//是否新文件(未保存过的)
 file currentfile;//当前文件名
 //构造函数开始
 public notepad()
 { 
 super("java记事本");
 //改变系统默认字体
 font font = new font("dialog", font.plain, 12);
 java.util.enumeration keys = uimanager.getdefaults().keys();
 while (keys.hasmoreelements()) {
 object key = keys.nextelement();
 object value = uimanager.get(key);
 if (value instanceof javax.swing.plaf.fontuiresource) {
 uimanager.put(key, font);
 }
 }
 //创建菜单条
 jmenubar menubar=new jmenubar();
 //创建文件菜单及菜单项并注册事件监听
 filemenu=new jmenu("文件(f)");
 filemenu.setmnemonic('f');//设置快捷键alt+f

 filemenu_new=new jmenuitem("新建(n)");
 filemenu_new.setaccelerator(keystroke.getkeystroke(keyevent.vk_n,inputevent.ctrl_mask));
 filemenu_new.addactionlistener(this);

 filemenu_open=new jmenuitem("打开(o)...");
 filemenu_open.setaccelerator(keystroke.getkeystroke(keyevent.vk_o,inputevent.ctrl_mask));
 filemenu_open.addactionlistener(this);

 filemenu_save=new jmenuitem("保存(s)");
 filemenu_save.setaccelerator(keystroke.getkeystroke(keyevent.vk_s,inputevent.ctrl_mask));
 filemenu_save.addactionlistener(this);

 filemenu_saveas=new jmenuitem("另存为(a)...");
 filemenu_saveas.addactionlistener(this);

 filemenu_pagesetup=new jmenuitem("页面设置(u)...");
 filemenu_pagesetup.addactionlistener(this);

 filemenu_print=new jmenuitem("打印(p)...");
 filemenu_print.setaccelerator(keystroke.getkeystroke(keyevent.vk_p, inputevent.ctrl_mask)); 
 filemenu_print.addactionlistener(this);

 filemenu_exit=new jmenuitem("退出(x)");
 filemenu_exit.addactionlistener(this);

 //创建编辑菜单及菜单项并注册事件监听
 editmenu=new jmenu("编辑(e)");
 editmenu.setmnemonic('e');//设置快捷键alt+e
 //当选择编辑菜单时，设置剪切、复制、粘贴、删除等功能的可用性
 editmenu.addmenulistener(new menulistener()
 { public void menucanceled(menuevent e)//取消菜单时调用
 { checkmenuitemenabled();//设置剪切、复制、粘贴、删除等功能的可用性
 }
 public void menudeselected(menuevent e)//取消选择某个菜单时调用
 { checkmenuitemenabled();//设置剪切、复制、粘贴、删除等功能的可用性
 }
 public void menuselected(menuevent e)//选择某个菜单时调用
 { checkmenuitemenabled();//设置剪切、复制、粘贴、删除等功能的可用性
 }
 });

 editmenu_undo=new jmenuitem("撤销(u)");
 editmenu_undo.setaccelerator(keystroke.getkeystroke(keyevent.vk_z,inputevent.ctrl_mask));
 editmenu_undo.addactionlistener(this);
 editmenu_undo.setenabled(false);

 editmenu_cut=new jmenuitem("剪切(t)");
 editmenu_cut.setaccelerator(keystroke.getkeystroke(keyevent.vk_x,inputevent.ctrl_mask));
 editmenu_cut.addactionlistener(this);

 editmenu_copy=new jmenuitem("复制(c)");
 editmenu_copy.setaccelerator(keystroke.getkeystroke(keyevent.vk_c,inputevent.ctrl_mask));
 editmenu_copy.addactionlistener(this);

 editmenu_paste=new jmenuitem("粘贴(p)");
 editmenu_paste.setaccelerator(keystroke.getkeystroke(keyevent.vk_v,inputevent.ctrl_mask));
 editmenu_paste.addactionlistener(this);

 editmenu_delete=new jmenuitem("删除(d)");
 editmenu_delete.setaccelerator(keystroke.getkeystroke(keyevent.vk_delete,0));
 editmenu_delete.addactionlistener(this);

 editmenu_find=new jmenuitem("查找(f)...");
 editmenu_find.setaccelerator(keystroke.getkeystroke(keyevent.vk_f,inputevent.ctrl_mask));
 editmenu_find.addactionlistener(this);

 editmenu_findnext=new jmenuitem("查找下一个(n)");
 editmenu_findnext.setaccelerator(keystroke.getkeystroke(keyevent.vk_f3,0));
 editmenu_findnext.addactionlistener(this);

 editmenu_replace = new jmenuitem("替换(r)...",'r'); 
 editmenu_replace.setaccelerator(keystroke.getkeystroke(keyevent.vk_h, inputevent.ctrl_mask)); 
 editmenu_replace.addactionlistener(this);

 editmenu_goto = new jmenuitem("转到(g)...",'g'); 
 editmenu_goto.setaccelerator(keystroke.getkeystroke(keyevent.vk_g, inputevent.ctrl_mask)); 
 editmenu_goto.addactionlistener(this);

 editmenu_selectall = new jmenuitem("全选",'a'); 
 editmenu_selectall.setaccelerator(keystroke.getkeystroke(keyevent.vk_a, inputevent.ctrl_mask)); 
 editmenu_selectall.addactionlistener(this);

 editmenu_timedate = new jmenuitem("时间/日期(d)",'d');
 editmenu_timedate.setaccelerator(keystroke.getkeystroke(keyevent.vk_f5,0));
 editmenu_timedate.addactionlistener(this);

 //创建格式菜单及菜单项并注册事件监听
 formatmenu=new jmenu("格式(o)");
 formatmenu.setmnemonic('o');//设置快捷键alt+o

 formatmenu_linewrap=new jcheckboxmenuitem("自动换行(w)");
 formatmenu_linewrap.setmnemonic('w');//设置快捷键alt+w
 formatmenu_linewrap.setstate(true);
 formatmenu_linewrap.addactionlistener(this);

 formatmenu_font=new jmenuitem("字体(f)...");
 formatmenu_font.addactionlistener(this);

 //创建查看菜单及菜单项并注册事件监听
 viewmenu=new jmenu("查看(v)");
 viewmenu.setmnemonic('v');//设置快捷键alt+v

 viewmenu_status=new jcheckboxmenuitem("状态栏(s)");
 viewmenu_status.setmnemonic('s');//设置快捷键alt+s
 viewmenu_status.setstate(true);
 viewmenu_status.addactionlistener(this);

 //创建帮助菜单及菜单项并注册事件监听
 helpmenu = new jmenu("帮助(h)");
 helpmenu.setmnemonic('h');//设置快捷键alt+h

 helpmenu_helptopics = new jmenuitem("帮助主题(h)"); 
 helpmenu_helptopics.setaccelerator(keystroke.getkeystroke(keyevent.vk_f1,0));
 helpmenu_helptopics.addactionlistener(this);

 helpmenu_aboutnotepad = new jmenuitem("关于记事本(a)"); 
 helpmenu_aboutnotepad.addactionlistener(this);

 //向菜单条添加"文件"菜单及菜单项
 menubar.add(filemenu); 
 filemenu.add(filemenu_new); 
 filemenu.add(filemenu_open); 
 filemenu.add(filemenu_save); 
 filemenu.add(filemenu_saveas); 
 filemenu.addseparator(); //分隔线
 filemenu.add(filemenu_pagesetup); 
 filemenu.add(filemenu_print); 
 filemenu.addseparator(); //分隔线 
 filemenu.add(filemenu_exit); 

 //向菜单条添加"编辑"菜单及菜单项 
 menubar.add(editmenu); 
 editmenu.add(editmenu_undo); 
 editmenu.addseparator(); //分隔线 
 editmenu.add(editmenu_cut); 
 editmenu.add(editmenu_copy); 
 editmenu.add(editmenu_paste); 
 editmenu.add(editmenu_delete); 
 editmenu.addseparator(); //分隔线
 editmenu.add(editmenu_find); 
 editmenu.add(editmenu_findnext); 
 editmenu.add(editmenu_replace);
 editmenu.add(editmenu_goto); 
 editmenu.addseparator(); //分隔线
 editmenu.add(editmenu_selectall); 
 editmenu.add(editmenu_timedate);

 //向菜单条添加"格式"菜单及菜单项 
 menubar.add(formatmenu); 
 formatmenu.add(formatmenu_linewrap); 
 formatmenu.add(formatmenu_font);

 //向菜单条添加"查看"菜单及菜单项 
 menubar.add(viewmenu); 
 viewmenu.add(viewmenu_status);

 //向菜单条添加"帮助"菜单及菜单项
 menubar.add(helpmenu);
 helpmenu.add(helpmenu_helptopics);
 helpmenu.addseparator();
 helpmenu.add(helpmenu_aboutnotepad);
 
 //向窗口添加菜单条 
 this.setjmenubar(menubar);

 //创建文本编辑区并添加滚动条
 editarea=new jtextarea(20,50);
 jscrollpane scroller=new jscrollpane(editarea);
 scroller.setverticalscrollbarpolicy(jscrollpane.vertical_scrollbar_always);
 this.add(scroller,borderlayout.center);//向窗口添加文本编辑区
 editarea.setwrapstyleword(true);//设置单词在一行不足容纳时换行
 editarea.setlinewrap(true);//设置文本编辑区自动换行默认为true,即会"自动换行"
 //this.add(editarea,borderlayout.center);//向窗口添加文本编辑区
 oldvalue=editarea.gettext();//获取原文本编辑区的内容

 //编辑区注册事件监听(与撤销操作有关)
 editarea.getdocument().addundoableeditlistener(undohandler);
 editarea.getdocument().adddocumentlistener(this);

 //创建右键弹出菜单
 popupmenu=new jpopupmenu();
 popupmenu_undo=new jmenuitem("撤销(u)");
 popupmenu_cut=new jmenuitem("剪切(t)");
 popupmenu_copy=new jmenuitem("复制(c)");
 popupmenu_paste=new jmenuitem("粘帖(p)");
 popupmenu_delete=new jmenuitem("删除(d)");
 popupmenu_selectall=new jmenuitem("全选(a)");

 popupmenu_undo.setenabled(false);

 //向右键菜单添加菜单项和分隔符
 popupmenu.add(popupmenu_undo);
 popupmenu.addseparator();
 popupmenu.add(popupmenu_cut);
 popupmenu.add(popupmenu_copy);
 popupmenu.add(popupmenu_paste);
 popupmenu.add(popupmenu_delete);
 popupmenu.addseparator();
 popupmenu.add(popupmenu_selectall);

 //文本编辑区注册右键菜单事件
 popupmenu_undo.addactionlistener(this);
 popupmenu_cut.addactionlistener(this);
 popupmenu_copy.addactionlistener(this);
 popupmenu_paste.addactionlistener(this);
 popupmenu_delete.addactionlistener(this);
 popupmenu_selectall.addactionlistener(this);

 //文本编辑区注册右键菜单事件
 editarea.addmouselistener(new mouseadapter()
 { public void mousepressed(mouseevent e)
 { if(e.ispopuptrigger())//返回此鼠标事件是否为该平台的弹出菜单触发事件
 { popupmenu.show(e.getcomponent(),e.getx(),e.gety());//在组件调用者的坐标空间中的位置 x、y 显示弹出菜单
 }
 checkmenuitemenabled();//设置剪切，复制，粘帖，删除等功能的可用性
 editarea.requestfocus();//编辑区获取焦点
 }
 public void mousereleased(mouseevent e)
 { if(e.ispopuptrigger())//返回此鼠标事件是否为该平台的弹出菜单触发事件
 { popupmenu.show(e.getcomponent(),e.getx(),e.gety());//在组件调用者的坐标空间中的位置 x、y 显示弹出菜单
 }
 checkmenuitemenabled();//设置剪切，复制，粘帖，删除等功能的可用性
 editarea.requestfocus();//编辑区获取焦点
 }
 });//文本编辑区注册右键菜单事件结束

 //创建和添加状态栏
 statuslabel=new jlabel("　按f1获取帮助");
 this.add(statuslabel,borderlayout.south);//向窗口添加状态栏标签

 //设置窗口在屏幕上的位置、大小和可见性 
 this.setlocation(100,100);
 this.setsize(650,550);
 this.setvisible(true);
 //添加窗口监听器
 addwindowlistener(new windowadapter()
 { public void windowclosing(windowevent e)
 { exitwindowchoose();
 }
 });

 checkmenuitemenabled();
 editarea.requestfocus();
 }//构造函数notepad结束
 
 //设置菜单项的可用性：剪切，复制，粘帖，删除功能
 public void checkmenuitemenabled()
 { string selecttext=editarea.getselectedtext();
 if(selecttext==null)
 { editmenu_cut.setenabled(false);
 popupmenu_cut.setenabled(false);
 editmenu_copy.setenabled(false);
 popupmenu_copy.setenabled(false);
 editmenu_delete.setenabled(false);
 popupmenu_delete.setenabled(false);
 }
 else
 { editmenu_cut.setenabled(true);
 popupmenu_cut.setenabled(true); 
 editmenu_copy.setenabled(true);
 popupmenu_copy.setenabled(true);
 editmenu_delete.setenabled(true);
 popupmenu_delete.setenabled(true);
 }
 //粘帖功能可用性判断
 transferable contents=clipboard.getcontents(this);
 if(contents==null)
 { editmenu_paste.setenabled(false);
 popupmenu_paste.setenabled(false);
 }
 else
 { editmenu_paste.setenabled(true);
 popupmenu_paste.setenabled(true); 
 }
 }//方法checkmenuitemenabled()结束

 //关闭窗口时调用
 public void exitwindowchoose()
 { editarea.requestfocus();
 string currentvalue=editarea.gettext();
 if(currentvalue.equals(oldvalue)==true)
 { system.exit(0);
 }
 else
 { int exitchoose=joptionpane.showconfirmdialog(this,"您的文件尚未保存，是否保存？","退出提示",joptionpane.yes_no_cancel_option);
 if(exitchoose==joptionpane.yes_option)
 { //boolean issave=false;
 if(isnewfile)
 { 
  string str=null;
  jfilechooser filechooser=new jfilechooser();
  filechooser.setfileselectionmode(jfilechooser.files_only);
  filechooser.setapprovebuttontext("确定");
  filechooser.setdialogtitle("另存为");
  
  int result=filechooser.showsavedialog(this);
  
  if(result==jfilechooser.cancel_option)
  { statuslabel.settext("　您没有保存文件");
  return;
  }  
 
  file savefilename=filechooser.getselectedfile();
 
  if(savefilename==null||savefilename.getname().equals(""))
  { joptionpane.showmessagedialog(this,"不合法的文件名","不合法的文件名",joptionpane.error_message);
  }
  else 
  { try
  { filewriter fw=new filewriter(savefilename);
  bufferedwriter bfw=new bufferedwriter(fw);
  bfw.write(editarea.gettext(),0,editarea.gettext().length());
  bfw.flush();
  fw.close();
  
  isnewfile=false;
  currentfile=savefilename;
  oldvalue=editarea.gettext();
  
  this.settitle(savefilename.getname()+" - 记事本");
  statuslabel.settext("　当前打开文件:"+savefilename.getabsolutefile());
  //issave=true;
  }  
  catch(ioexception ioexception){  
  } 
  }
 }
 else
 {
  try
  { filewriter fw=new filewriter(currentfile);
  bufferedwriter bfw=new bufferedwriter(fw);
  bfw.write(editarea.gettext(),0,editarea.gettext().length());
  bfw.flush();
  fw.close();
  //issave=true;
  }  
  catch(ioexception ioexception){  
  }
 }
 system.exit(0);
 //if(issave)system.exit(0);
 //else return;
 }
 else if(exitchoose==joptionpane.no_option)
 { system.exit(0);
 }
 else
 { return;
 }
 }
 }//关闭窗口时调用方法结束

 //查找方法
 public void find()
 { final jdialog finddialog=new jdialog(this,"查找",false);//false时允许其他窗口同时处于激活状态(即无模式)
 container con=finddialog.getcontentpane();//返回此对话框的contentpane对象 
 con.setlayout(new flowlayout(flowlayout.left));
 jlabel findcontentlabel=new jlabel("查找内容(n)：");
 final jtextfield findtext=new jtextfield(15);
 jbutton findnextbutton=new jbutton("查找下一个(f)：");
 final jcheckbox matchcheckbox=new jcheckbox("区分大小写(c)");
 buttongroup bgroup=new buttongroup();
 final jradiobutton upbutton=new jradiobutton("向上(u)");
 final jradiobutton downbutton=new jradiobutton("向下(u)");
 downbutton.setselected(true);
 bgroup.add(upbutton);
 bgroup.add(downbutton);
 /*buttongroup此类用于为一组按钮创建一个多斥（multiple-exclusion）作用域。
 使用相同的 buttongroup 对象创建一组按钮意味着“开启”其中一个按钮时，将关闭组中的其他所有按钮。*/
 /*jradiobutton此类实现一个单选按钮，此按钮项可被选择或取消选择，并可为用户显示其状态。
 与 buttongroup 对象配合使用可创建一组按钮，一次只能选择其中的一个按钮。
 （创建一个 buttongroup 对象并用其 add 方法将 jradiobutton 对象包含在此组中。）*/
 jbutton cancel=new jbutton("取消");
 //取消按钮事件处理
 cancel.addactionlistener(new actionlistener()
 { public void actionperformed(actionevent e)
 { finddialog.dispose();
 }
 });
 //"查找下一个"按钮监听
 findnextbutton.addactionlistener(new actionlistener()
 { public void actionperformed(actionevent e)
 { //"区分大小写(c)"的jcheckbox是否被选中
 int k=0,m=0;
 final string str1,str2,str3,str4,stra,strb;
 str1=editarea.gettext();
 str2=findtext.gettext();
 str3=str1.touppercase();
 str4=str2.touppercase();
 if(matchcheckbox.isselected())//区分大小写
 { stra=str1;
  strb=str2;
 }
 else//不区分大小写,此时把所选内容全部化成大写(或小写)，以便于查找 
 { stra=str3;
  strb=str4;
 }
 if(upbutton.isselected())
 { //k=stra.lastindexof(strb,editarea.getcaretposition()-1);
  if(editarea.getselectedtext()==null)
  k=stra.lastindexof(strb,editarea.getcaretposition()-1);
  else
  k=stra.lastindexof(strb, editarea.getcaretposition()-findtext.gettext().length()-1); 
  if(k>-1)
  { //string strdata=stra.substring(k,strb.gettext().length()+1);
  editarea.setcaretposition(k);
  editarea.select(k,k+strb.length());
  }
  else
  { joptionpane.showmessagedialog(null,"找不到您查找的内容！","查找",joptionpane.information_message);
  }
 }
 else if(downbutton.isselected())
 { if(editarea.getselectedtext()==null)
  k=stra.indexof(strb,editarea.getcaretposition()+1);
  else
  k=stra.indexof(strb, editarea.getcaretposition()-findtext.gettext().length()+1); 
  if(k>-1)
  { //string strdata=stra.substring(k,strb.gettext().length()+1);
  editarea.setcaretposition(k);
  editarea.select(k,k+strb.length());
  }
  else
  { joptionpane.showmessagedialog(null,"找不到您查找的内容！","查找",joptionpane.information_message);
  }
 }
 }
 });//"查找下一个"按钮监听结束
 //创建"查找"对话框的界面
 jpanel panel1=new jpanel();
 jpanel panel2=new jpanel();
 jpanel panel3=new jpanel();
 jpanel directionpanel=new jpanel();
 directionpanel.setborder(borderfactory.createtitledborder("方向"));
 //设置directionpanel组件的边框;
 //borderfactory.createtitledborder(string title)创建一个新标题边框，使用默认边框（浮雕化）、默认文本位置（位于顶线上）、默认调整 (leading) 以及由当前外观确定的默认字体和文本颜色，并指定了标题文本。
 directionpanel.add(upbutton);
 directionpanel.add(downbutton);
 panel1.setlayout(new gridlayout(2,1));
 panel1.add(findnextbutton);
 panel1.add(cancel);
 panel2.add(findcontentlabel);
 panel2.add(findtext);
 panel2.add(panel1);
 panel3.add(matchcheckbox);
 panel3.add(directionpanel);
 con.add(panel2);
 con.add(panel3);
 finddialog.setsize(410,180);
 finddialog.setresizable(false);//不可调整大小
 finddialog.setlocation(230,280);
 finddialog.setvisible(true);
 }//查找方法结束
 
 //替换方法
 public void replace()
 { final jdialog replacedialog=new jdialog(this,"替换",false);//false时允许其他窗口同时处于激活状态(即无模式)
 container con=replacedialog.getcontentpane();//返回此对话框的contentpane对象
 con.setlayout(new flowlayout(flowlayout.center));
 jlabel findcontentlabel=new jlabel("查找内容(n)：");
 final jtextfield findtext=new jtextfield(15);
 jbutton findnextbutton=new jbutton("查找下一个(f):");
 jlabel replacelabel=new jlabel("替换为(p)：");
 final jtextfield replacetext=new jtextfield(15);
 jbutton replacebutton=new jbutton("替换(r)");
 jbutton replaceallbutton=new jbutton("全部替换(a)");
 jbutton cancel=new jbutton("取消");
 cancel.addactionlistener(new actionlistener()
 { public void actionperformed(actionevent e)
 { replacedialog.dispose();
 }
 });
 final jcheckbox matchcheckbox=new jcheckbox("区分大小写(c)");
 buttongroup bgroup=new buttongroup();
 final jradiobutton upbutton=new jradiobutton("向上(u)");
 final jradiobutton downbutton=new jradiobutton("向下(u)");
 downbutton.setselected(true);
 bgroup.add(upbutton);
 bgroup.add(downbutton);
 /*buttongroup此类用于为一组按钮创建一个多斥（multiple-exclusion）作用域。
 使用相同的 buttongroup 对象创建一组按钮意味着“开启”其中一个按钮时，将关闭组中的其他所有按钮。*/
 /*jradiobutton此类实现一个单选按钮，此按钮项可被选择或取消选择，并可为用户显示其状态。
 与 buttongroup 对象配合使用可创建一组按钮，一次只能选择其中的一个按钮。
 （创建一个 buttongroup 对象并用其 add 方法将 jradiobutton 对象包含在此组中。）*/
 
 //"查找下一个"按钮监听
 findnextbutton.addactionlistener(new actionlistener()
 { public void actionperformed(actionevent e)
 { //"区分大小写(c)"的jcheckbox是否被选中
 int k=0,m=0;
 final string str1,str2,str3,str4,stra,strb;
 str1=editarea.gettext();
 str2=findtext.gettext();
 str3=str1.touppercase();
 str4=str2.touppercase();
 if(matchcheckbox.isselected())//区分大小写
 { stra=str1;
  strb=str2;
 }
 else//不区分大小写,此时把所选内容全部化成大写(或小写)，以便于查找 
 { stra=str3;
  strb=str4;
 }
 if(upbutton.isselected())
 { //k=stra.lastindexof(strb,editarea.getcaretposition()-1);
  if(editarea.getselectedtext()==null)
  k=stra.lastindexof(strb,editarea.getcaretposition()-1);
  else
  k=stra.lastindexof(strb, editarea.getcaretposition()-findtext.gettext().length()-1); 
  if(k>-1)
  { //string strdata=stra.substring(k,strb.gettext().length()+1);
  editarea.setcaretposition(k);
  editarea.select(k,k+strb.length());
  }
  else
  { joptionpane.showmessagedialog(null,"找不到您查找的内容！","查找",joptionpane.information_message);
  }
 }
 else if(downbutton.isselected())
 { if(editarea.getselectedtext()==null)
  k=stra.indexof(strb,editarea.getcaretposition()+1);
  else
  k=stra.indexof(strb, editarea.getcaretposition()-findtext.gettext().length()+1); 
  if(k>-1)
  { //string strdata=stra.substring(k,strb.gettext().length()+1);
  editarea.setcaretposition(k);
  editarea.select(k,k+strb.length());
  }
  else
  { joptionpane.showmessagedialog(null,"找不到您查找的内容！","查找",joptionpane.information_message);
  }
 }
 }
 });//"查找下一个"按钮监听结束
 
 //"替换"按钮监听
 replacebutton.addactionlistener(new actionlistener()
 { public void actionperformed(actionevent e)
 { if(replacetext.gettext().length()==0 && editarea.getselectedtext()!=null) 
  editarea.replaceselection(""); 
 if(replacetext.gettext().length()>0 && editarea.getselectedtext()!=null) 
  editarea.replaceselection(replacetext.gettext());
 }
 });//"替换"按钮监听结束
 
 //"全部替换"按钮监听
 replaceallbutton.addactionlistener(new actionlistener()
 { public void actionperformed(actionevent e)
 { editarea.setcaretposition(0); //将光标放到编辑区开头 
 int k=0,m=0,replacecount=0;
 if(findtext.gettext().length()==0)
 { joptionpane.showmessagedialog(replacedialog,"请填写查找内容!","提示",joptionpane.warning_message);
  findtext.requestfocus(true);
  return;
 }
 while(k>-1)//当文本中有内容被选中时(k>-1被选中)进行替换，否则不进行while循环
 { //"区分大小写(c)"的jcheckbox是否被选中
  //int k=0,m=0;
  final string str1,str2,str3,str4,stra,strb;
  str1=editarea.gettext();
  str2=findtext.gettext();
  str3=str1.touppercase();
  str4=str2.touppercase();
  if(matchcheckbox.isselected())//区分大小写
  { stra=str1;
  strb=str2;
  }
  else//不区分大小写,此时把所选内容全部化成大写(或小写)，以便于查找 
  { stra=str3;
  strb=str4;
  }
  if(upbutton.isselected())
  { //k=stra.lastindexof(strb,editarea.getcaretposition()-1);
  if(editarea.getselectedtext()==null)
  k=stra.lastindexof(strb,editarea.getcaretposition()-1);
  else
  k=stra.lastindexof(strb, editarea.getcaretposition()-findtext.gettext().length()-1); 
  if(k>-1)
  { //string strdata=stra.substring(k,strb.gettext().length()+1);
  editarea.setcaretposition(k);
  editarea.select(k,k+strb.length());
  }
  else
  { if(replacecount==0)
  { joptionpane.showmessagedialog(replacedialog, "找不到您查找的内容!", "记事本",joptionpane.information_message); 
  }
  else
  { joptionpane.showmessagedialog(replacedialog,"成功替换"+replacecount+"个匹配内容!","替换成功",joptionpane.information_message);
  }
  }
  }
  else if(downbutton.isselected())
  { if(editarea.getselectedtext()==null)
  k=stra.indexof(strb,editarea.getcaretposition()+1);
  else
  k=stra.indexof(strb, editarea.getcaretposition()-findtext.gettext().length()+1); 
  if(k>-1)
  { //string strdata=stra.substring(k,strb.gettext().length()+1);
  editarea.setcaretposition(k);
  editarea.select(k,k+strb.length());
  }
  else
  { if(replacecount==0)
  { joptionpane.showmessagedialog(replacedialog, "找不到您查找的内容!", "记事本",joptionpane.information_message); 
  }
  else
  { joptionpane.showmessagedialog(replacedialog,"成功替换"+replacecount+"个匹配内容!","替换成功",joptionpane.information_message);
  }
  }
  }
  if(replacetext.gettext().length()==0 && editarea.getselectedtext()!= null)
  { editarea.replaceselection("");
  replacecount++;
  } 
  
  if(replacetext.gettext().length()>0 && editarea.getselectedtext()!= null) 
  { editarea.replaceselection(replacetext.gettext()); 
  replacecount++;
  }
 }//while循环结束
 }
 });//"替换全部"方法结束
 
 //创建"替换"对话框的界面
 jpanel directionpanel=new jpanel();
 directionpanel.setborder(borderfactory.createtitledborder("方向"));
 //设置directionpanel组件的边框;
 //borderfactory.createtitledborder(string title)创建一个新标题边框，使用默认边框（浮雕化）、默认文本位置（位于顶线上）、默认调整 (leading) 以及由当前外观确定的默认字体和文本颜色，并指定了标题文本。
 directionpanel.add(upbutton);
 directionpanel.add(downbutton);
 jpanel panel1=new jpanel();
 jpanel panel2=new jpanel();
 jpanel panel3=new jpanel();
 jpanel panel4=new jpanel();
 panel4.setlayout(new gridlayout(2,1));
 panel1.add(findcontentlabel);
 panel1.add(findtext);
 panel1.add(findnextbutton);
 panel4.add(replacebutton);
 panel4.add(replaceallbutton);
 panel2.add(replacelabel);
 panel2.add(replacetext);
 panel2.add(panel4);
 panel3.add(matchcheckbox);
 panel3.add(directionpanel);
 panel3.add(cancel);
 con.add(panel1);
 con.add(panel2);
 con.add(panel3);
 replacedialog.setsize(420,220);
 replacedialog.setresizable(false);//不可调整大小
 replacedialog.setlocation(230,280);
 replacedialog.setvisible(true);
 }//"全部替换"按钮监听结束

 //"字体"方法
 public void font()
 { final jdialog fontdialog=new jdialog(this,"字体设置",false);
 container con=fontdialog.getcontentpane();
 con.setlayout(new flowlayout(flowlayout.left));
 jlabel fontlabel=new jlabel("字体(f)：");
 fontlabel.setpreferredsize(new dimension(100,20));//构造一个dimension，并将其初始化为指定宽度和高度
 jlabel stylelabel=new jlabel("字形(y)：");
 stylelabel.setpreferredsize(new dimension(100,20));
 jlabel sizelabel=new jlabel("大小(s)：");
 sizelabel.setpreferredsize(new dimension(100,20));
 final jlabel sample=new jlabel("张选仲的记事本-zxz's notepad");
 //sample.sethorizontalalignment(swingconstants.center);
 final jtextfield fonttext=new jtextfield(9);
 fonttext.setpreferredsize(new dimension(200,20));
 final jtextfield styletext=new jtextfield(8);
 styletext.setpreferredsize(new dimension(200,20));
 final int style[]={font.plain,font.bold,font.italic,font.bold+font.italic};
 final jtextfield sizetext=new jtextfield(5);
 sizetext.setpreferredsize(new dimension(200,20));
 jbutton okbutton=new jbutton("确定");
 jbutton cancel=new jbutton("取消");
 cancel.addactionlistener(new actionlistener()
 { public void actionperformed(actionevent e)
 { fontdialog.dispose(); 
 }
 });
 font currentfont=editarea.getfont();
 fonttext.settext(currentfont.getfontname());
 fonttext.selectall();
 //styletext.settext(currentfont.getstyle());
 //styletext.selectall();
 if(currentfont.getstyle()==font.plain)
 styletext.settext("常规");
 else if(currentfont.getstyle()==font.bold)
 styletext.settext("粗体");
 else if(currentfont.getstyle()==font.italic)
 styletext.settext("斜体");
 else if(currentfont.getstyle()==(font.bold+font.italic))
 styletext.settext("粗斜体");
 styletext.selectall();
 string str=string.valueof(currentfont.getsize());
 sizetext.settext(str);
 sizetext.selectall();
 final jlist fontlist,stylelist,sizelist;
 graphicsenvironment ge=graphicsenvironment.getlocalgraphicsenvironment();
 final string fontname[]=ge.getavailablefontfamilynames();
 fontlist=new jlist(fontname);
 fontlist.setfixedcellwidth(86);
 fontlist.setfixedcellheight(20);
 fontlist.setselectionmode(listselectionmodel.single_selection);
 final string fontstyle[]={"常规","粗体","斜体","粗斜体"};
 stylelist=new jlist(fontstyle);
 stylelist.setfixedcellwidth(86);
 stylelist.setfixedcellheight(20);
 stylelist.setselectionmode(listselectionmodel.single_selection);
 if(currentfont.getstyle()==font.plain)
 stylelist.setselectedindex(0);
 else if(currentfont.getstyle()==font.bold)
 stylelist.setselectedindex(1);
 else if(currentfont.getstyle()==font.italic)
 stylelist.setselectedindex(2);
 else if(currentfont.getstyle()==(font.bold+font.italic))
 stylelist.setselectedindex(3);
 final string fontsize[]={"8","9","10","11","12","14","16","18","20","22","24","26","28","36","48","72"};
 sizelist=new jlist(fontsize);
 sizelist.setfixedcellwidth(43);
 sizelist.setfixedcellheight(20);
 sizelist.setselectionmode(listselectionmodel.single_selection);
 fontlist.addlistselectionlistener(new listselectionlistener()
 { public void valuechanged(listselectionevent event)
 { fonttext.settext(fontname[fontlist.getselectedindex()]);
 fonttext.selectall();
 font samplefont1=new font(fonttext.gettext(),style[stylelist.getselectedindex()],integer.parseint(sizetext.gettext()));
 sample.setfont(samplefont1);
 }
 });
 stylelist.addlistselectionlistener(new listselectionlistener()
 { public void valuechanged(listselectionevent event)
 { int s=style[stylelist.getselectedindex()];
 styletext.settext(fontstyle[s]);
 styletext.selectall();
 font samplefont2=new font(fonttext.gettext(),style[stylelist.getselectedindex()],integer.parseint(sizetext.gettext()));
 sample.setfont(samplefont2);
 }
 });
 sizelist.addlistselectionlistener(new listselectionlistener()
 { public void valuechanged(listselectionevent event)
 { sizetext.settext(fontsize[sizelist.getselectedindex()]);
 //sizetext.requestfocus();
 sizetext.selectall(); 
 font samplefont3=new font(fonttext.gettext(),style[stylelist.getselectedindex()],integer.parseint(sizetext.gettext()));
 sample.setfont(samplefont3);
 }
 });
 okbutton.addactionlistener(new actionlistener()
 { public void actionperformed(actionevent e)
 { font okfont=new font(fonttext.gettext(),style[stylelist.getselectedindex()],integer.parseint(sizetext.gettext()));
 editarea.setfont(okfont);
 fontdialog.dispose();
 }
 });
 jpanel samplepanel=new jpanel();
 samplepanel.setborder(borderfactory.createtitledborder("示例"));
 //samplepanel.setlayout(new flowlayout(flowlayout.center));
 samplepanel.add(sample);
 jpanel panel1=new jpanel();
 jpanel panel2=new jpanel();
 jpanel panel3=new jpanel();
 //jpanel panel4=new jpanel();
 //jpanel panel5=new jpanel();
 //panel1.add(fontlabel);
 //panel1.add(stylelabel);
 //panel1.add(sizelabel);
 //panel2.add(fonttext);
 //panel2.add(new jscrollpane(fontlist));//jlist不支持直接滚动，所以要让jlist作为jscrollpane的视口视图
 //panel2.setlayout(new gridlayout(2,1));
 //panel3.add(styletext);
 //panel3.add(new jscrollpane(stylelist));
 //panel3.setlayout(new gridlayout(2,1));
 //panel4.add(sizetext);
 //panel4.add(new jscrollpane(sizetext));
 //panel4.setlayout(new gridlayout(2,1));
 //panel5.add(okbutton);
 //panel5.add(cancel);
 //con.add(panel1);
 //con.add(panel2);
 //con.add(panel3);
 //con.add(panel4);
 //con.add(panel5);
 panel2.add(fonttext);
 panel2.add(styletext);
 panel2.add(sizetext);
 panel2.add(okbutton);
 panel3.add(new jscrollpane(fontlist));//jlist不支持直接滚动，所以要让jlist作为jscrollpane的视口视图
 panel3.add(new jscrollpane(stylelist));
 panel3.add(new jscrollpane(sizelist));
 panel3.add(cancel);
 con.add(panel1);
 con.add(panel2);
 con.add(panel3);
 con.add(samplepanel);
 fontdialog.setsize(350,340);
 fontdialog.setlocation(200,200);
 fontdialog.setresizable(false);
 fontdialog.setvisible(true);
 }

 //public void menuperformed(menuevent e)
 //{ checkmenuitemenabled();//设置剪切、复制、粘贴、删除等功能的可用性
 //}

 public void actionperformed(actionevent e)
 { //新建
 if(e.getsource()==filemenu_new)
 { editarea.requestfocus();
 string currentvalue=editarea.gettext();
 boolean istextchange=(currentvalue.equals(oldvalue))?false:true;
 if(istextchange)
 { int savechoose=joptionpane.showconfirmdialog(this,"您的文件尚未保存，是否保存？","提示",joptionpane.yes_no_cancel_option);
 if(savechoose==joptionpane.yes_option)
 { string str=null;
  jfilechooser filechooser=new jfilechooser();
  filechooser.setfileselectionmode(jfilechooser.files_only);
  //filechooser.setapprovebuttontext("确定");
  filechooser.setdialogtitle("另存为");
  int result=filechooser.showsavedialog(this);
  if(result==jfilechooser.cancel_option)
  { statuslabel.settext("您没有选择任何文件");
  return;
  }
  file savefilename=filechooser.getselectedfile();
  if(savefilename==null || savefilename.getname().equals(""))
  { joptionpane.showmessagedialog(this,"不合法的文件名","不合法的文件名",joptionpane.error_message);
  }
  else 
  { try
  { filewriter fw=new filewriter(savefilename);
  bufferedwriter bfw=new bufferedwriter(fw);
  bfw.write(editarea.gettext(),0,editarea.gettext().length());
  bfw.flush();//刷新该流的缓冲
  bfw.close();
  isnewfile=false;
  currentfile=savefilename;
  oldvalue=editarea.gettext();
  this.settitle(savefilename.getname()+" - 记事本");
  statuslabel.settext("当前打开文件："+savefilename.getabsolutefile());
  }
  catch (ioexception ioexception)
  {
  }
  }
 }
 else if(savechoose==joptionpane.no_option)
 { editarea.replacerange("",0,editarea.gettext().length());
  statuslabel.settext(" 新建文件");
  this.settitle("无标题 - 记事本");
  isnewfile=true;
  undo.discardalledits(); //撤消所有的"撤消"操作
  editmenu_undo.setenabled(false);
  oldvalue=editarea.gettext();
 }
 else if(savechoose==joptionpane.cancel_option)
 { return;
 }
 }
 else
 { editarea.replacerange("",0,editarea.gettext().length());
 statuslabel.settext(" 新建文件");
 this.settitle("无标题 - 记事本");
 isnewfile=true;
 undo.discardalledits();//撤消所有的"撤消"操作
 editmenu_undo.setenabled(false);
 oldvalue=editarea.gettext();
 }
 }//新建结束
 //打开
 else if(e.getsource()==filemenu_open)
 { editarea.requestfocus();
 string currentvalue=editarea.gettext();
 boolean istextchange=(currentvalue.equals(oldvalue))?false:true;
 if(istextchange)
 { int savechoose=joptionpane.showconfirmdialog(this,"您的文件尚未保存，是否保存？","提示",joptionpane.yes_no_cancel_option);
 if(savechoose==joptionpane.yes_option)
 { string str=null;
  jfilechooser filechooser=new jfilechooser();
  filechooser.setfileselectionmode(jfilechooser.files_only);
  //filechooser.setapprovebuttontext("确定");
  filechooser.setdialogtitle("另存为");
  int result=filechooser.showsavedialog(this);
  if(result==jfilechooser.cancel_option)
  { statuslabel.settext("您没有选择任何文件");
  return;
  }
  file savefilename=filechooser.getselectedfile();
  if(savefilename==null || savefilename.getname().equals(""))
  { joptionpane.showmessagedialog(this,"不合法的文件名","不合法的文件名",joptionpane.error_message);
  }
  else 
  { try
  { filewriter fw=new filewriter(savefilename);
  bufferedwriter bfw=new bufferedwriter(fw);
  bfw.write(editarea.gettext(),0,editarea.gettext().length());
  bfw.flush();//刷新该流的缓冲
  bfw.close();
  isnewfile=false;
  currentfile=savefilename;
  oldvalue=editarea.gettext();
  this.settitle(savefilename.getname()+" - 记事本");
  statuslabel.settext("当前打开文件："+savefilename.getabsolutefile());
  }
  catch (ioexception ioexception)
  {
  }
  }
 }
 else if(savechoose==joptionpane.no_option)
 { string str=null;
  jfilechooser filechooser=new jfilechooser();
  filechooser.setfileselectionmode(jfilechooser.files_only);
  //filechooser.setapprovebuttontext("确定");
  filechooser.setdialogtitle("打开文件");
  int result=filechooser.showopendialog(this);
  if(result==jfilechooser.cancel_option)
  { statuslabel.settext("您没有选择任何文件");
  return;
  }
  file filename=filechooser.getselectedfile();
  if(filename==null || filename.getname().equals(""))
  { joptionpane.showmessagedialog(this,"不合法的文件名","不合法的文件名",joptionpane.error_message);
  }
  else
  { try
  { filereader fr=new filereader(filename);
  bufferedreader bfr=new bufferedreader(fr);
  editarea.settext("");
  while((str=bfr.readline())!=null)
  { editarea.append(str);
  }
  this.settitle(filename.getname()+" - 记事本");
  statuslabel.settext(" 当前打开文件："+filename.getabsolutefile());
  fr.close();
  isnewfile=false;
  currentfile=filename;
  oldvalue=editarea.gettext();
  }
  catch (ioexception ioexception)
  {
  }
  }
 }
 else
 { return;
 }
 }
 else
 { string str=null;
 jfilechooser filechooser=new jfilechooser();
 filechooser.setfileselectionmode(jfilechooser.files_only);
 //filechooser.setapprovebuttontext("确定");
 filechooser.setdialogtitle("打开文件");
 int result=filechooser.showopendialog(this);
 if(result==jfilechooser.cancel_option)
 { statuslabel.settext(" 您没有选择任何文件 ");
  return;
 }
 file filename=filechooser.getselectedfile();
 if(filename==null || filename.getname().equals(""))
 { joptionpane.showmessagedialog(this,"不合法的文件名","不合法的文件名",joptionpane.error_message);
 }
 else
 { try
  { filereader fr=new filereader(filename);
  bufferedreader bfr=new bufferedreader(fr);
  editarea.settext("");
  while((str=bfr.readline())!=null)
  { editarea.append(str);
  }
  this.settitle(filename.getname()+" - 记事本");
  statuslabel.settext(" 当前打开文件："+filename.getabsolutefile());
  fr.close();
  isnewfile=false;
  currentfile=filename;
  oldvalue=editarea.gettext();
  }
  catch (ioexception ioexception)
  {
  }
 }
 }
 }//打开结束
 //保存
 else if(e.getsource()==filemenu_save)
 { editarea.requestfocus();
 if(isnewfile)
 { string str=null;
 jfilechooser filechooser=new jfilechooser();
 filechooser.setfileselectionmode(jfilechooser.files_only);
 //filechooser.setapprovebuttontext("确定");
 filechooser.setdialogtitle("保存");
 int result=filechooser.showsavedialog(this);
 if(result==jfilechooser.cancel_option)
 { statuslabel.settext("您没有选择任何文件");
  return;
 }
 file savefilename=filechooser.getselectedfile();
 if(savefilename==null || savefilename.getname().equals(""))
 { joptionpane.showmessagedialog(this,"不合法的文件名","不合法的文件名",joptionpane.error_message);
 }
 else 
 { try
  { filewriter fw=new filewriter(savefilename);
  bufferedwriter bfw=new bufferedwriter(fw);
  bfw.write(editarea.gettext(),0,editarea.gettext().length());
  bfw.flush();//刷新该流的缓冲
  bfw.close();
  isnewfile=false;
  currentfile=savefilename;
  oldvalue=editarea.gettext();
  this.settitle(savefilename.getname()+" - 记事本");
  statuslabel.settext("当前打开文件："+savefilename.getabsolutefile());
  }
  catch (ioexception ioexception)
  {
  }
 }
 }
 else
 { try
 { filewriter fw=new filewriter(currentfile);
  bufferedwriter bfw=new bufferedwriter(fw);
  bfw.write(editarea.gettext(),0,editarea.gettext().length());
  bfw.flush();
  fw.close();
 }  
 catch(ioexception ioexception)
 {  
 }
 }
 }//保存结束
 //另存为
 else if(e.getsource()==filemenu_saveas)
 { editarea.requestfocus();
 string str=null;
 jfilechooser filechooser=new jfilechooser();
 filechooser.setfileselectionmode(jfilechooser.files_only);
 //filechooser.setapprovebuttontext("确定");
 filechooser.setdialogtitle("另存为");
 int result=filechooser.showsavedialog(this);
 if(result==jfilechooser.cancel_option)
 { statuslabel.settext("　您没有选择任何文件");
 return;
 } 
 file savefilename=filechooser.getselectedfile();
 if(savefilename==null||savefilename.getname().equals(""))
 { joptionpane.showmessagedialog(this,"不合法的文件名","不合法的文件名",joptionpane.error_message);
 } 
 else 
 { try
 { filewriter fw=new filewriter(savefilename);
  bufferedwriter bfw=new bufferedwriter(fw);
  bfw.write(editarea.gettext(),0,editarea.gettext().length());
  bfw.flush();
  fw.close();
  oldvalue=editarea.gettext();
  this.settitle(savefilename.getname()+" - 记事本");
  statuslabel.settext("　当前打开文件:"+savefilename.getabsolutefile());
 }  
 catch(ioexception ioexception)
 {  
 } 
 }
 }//另存为结束
 //页面设置
 else if(e.getsource()==filemenu_pagesetup)
 { editarea.requestfocus();
 joptionpane.showmessagedialog(this,"对不起，此功能尚未实现！更多请看http://pan.muyi.so","提示",joptionpane.warning_message);
 }//页面设置结束
 //打印
 else if(e.getsource()==filemenu_print)
 { editarea.requestfocus();
 joptionpane.showmessagedialog(this,"对不起，此功能尚未实现！更多请看http://pan.muyi.so","提示",joptionpane.warning_message);
 }//打印结束
 //退出
 else if(e.getsource()==filemenu_exit)
 { int exitchoose=joptionpane.showconfirmdialog(this,"确定要退出吗?","退出提示",joptionpane.ok_cancel_option);
 if(exitchoose==joptionpane.ok_option)
 { system.exit(0);
 }
 else
 { return;
 }
 }//退出结束
 //编辑
 //else if(e.getsource()==editmenu)
 //{ checkmenuitemenabled();//设置剪切、复制、粘贴、删除等功能的可用性
 //}
 //编辑结束
 //撤销
 else if(e.getsource()==editmenu_undo || e.getsource()==popupmenu_undo)
 { editarea.requestfocus();
 if(undo.canundo())
 { try
 { undo.undo();
 }
 catch (cannotundoexception ex)
 { system.out.println("unable to undo:" + ex);
  //ex.printstacktrace();
 }
 }
 if(!undo.canundo())
 { editmenu_undo.setenabled(false);
 }
 }//撤销结束
 //剪切
 else if(e.getsource()==editmenu_cut || e.getsource()==popupmenu_cut)
 { editarea.requestfocus();
 string text=editarea.getselectedtext();
 stringselection selection=new stringselection(text);
 clipboard.setcontents(selection,null);
 editarea.replacerange("",editarea.getselectionstart(),editarea.getselectionend());
 checkmenuitemenabled();//设置剪切，复制，粘帖，删除功能的可用性
 }//剪切结束
 //复制
 else if(e.getsource()==editmenu_copy || e.getsource()==popupmenu_copy)
 { editarea.requestfocus();
 string text=editarea.getselectedtext();
 stringselection selection=new stringselection(text);
 clipboard.setcontents(selection,null);
 checkmenuitemenabled();//设置剪切，复制，粘帖，删除功能的可用性
 }//复制结束
 //粘帖
 else if(e.getsource()==editmenu_paste || e.getsource()==popupmenu_paste)
 { editarea.requestfocus();
 transferable contents=clipboard.getcontents(this);
 if(contents==null)return;
 string text="";
 try
 { text=(string)contents.gettransferdata(dataflavor.stringflavor);
 }
 catch (exception exception)
 {
 }
 editarea.replacerange(text,editarea.getselectionstart(),editarea.getselectionend());
 checkmenuitemenabled();
 }//粘帖结束
 //删除
 else if(e.getsource()==editmenu_delete || e.getsource()==popupmenu_delete)
 { editarea.requestfocus();
 editarea.replacerange("",editarea.getselectionstart(),editarea.getselectionend());
 checkmenuitemenabled(); //设置剪切、复制、粘贴、删除等功能的可用性 
 }//删除结束
 //查找
 else if(e.getsource()==editmenu_find)
 { editarea.requestfocus();
 find();
 }//查找结束
 //查找下一个
 else if(e.getsource()==editmenu_findnext)
 { editarea.requestfocus();
 find();
 }//查找下一个结束
 //替换
 else if(e.getsource()==editmenu_replace)
 { editarea.requestfocus();
 replace();
 }//替换结束
 //转到
 else if(e.getsource()==editmenu_goto)
 { editarea.requestfocus();
 joptionpane.showmessagedialog(this,"对不起，此功能尚未实现！更多请看http://pan.muyi.so","提示",joptionpane.warning_message);
 }//转到结束
 //时间日期
 else if(e.getsource()==editmenu_timedate)
 { editarea.requestfocus();
 //simpledateformat currentdatetime=new simpledateformat("hh:mmyyyy-mm-dd");
 //editarea.insert(currentdatetime.format(new date()),editarea.getcaretposition());
 calendar rightnow=calendar.getinstance();
 date date=rightnow.gettime();
 editarea.insert(date.tostring(),editarea.getcaretposition());
 }//时间日期结束
 //全选
 else if(e.getsource()==editmenu_selectall || e.getsource()==popupmenu_selectall)
 { editarea.selectall();
 }//全选结束
 //自动换行(已在前面设置)
 else if(e.getsource()==formatmenu_linewrap)
 { if(formatmenu_linewrap.getstate())
 editarea.setlinewrap(true);
 else 
 editarea.setlinewrap(false);

 }//自动换行结束
 //字体设置
 else if(e.getsource()==formatmenu_font)
 { editarea.requestfocus();
 font();
 }//字体设置结束
 //设置状态栏可见性
 else if(e.getsource()==viewmenu_status)
 { if(viewmenu_status.getstate())
 statuslabel.setvisible(true);
 else 
 statuslabel.setvisible(false);
 }//设置状态栏可见性结束
 //帮助主题
 else if(e.getsource()==helpmenu_helptopics)
 { editarea.requestfocus();
 joptionpane.showmessagedialog(this,"路漫漫其修远兮，吾将上下而求索。","帮助主题",joptionpane.information_message);
 }//帮助主题结束
 //关于
 else if(e.getsource()==helpmenu_aboutnotepad)
 { editarea.requestfocus();
 joptionpane.showmessagedialog(this,
 "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&\n"+
 " 编写者：沐伊科技 \n"+
 " 编写时间：2016-06-09       \n"+
 " 更多教程：http://pan.muyi.so (网盘资源教程应有尽有哦!)  \n"+
 " e-mail：llqqxf@163.com    \n"+
 " 一些地方借鉴他人，不足之处希望大家能提出意见，谢谢！ \n"+
 "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&\n",
 "记事本",joptionpane.information_message);
 }//关于结束
 }//方法actionperformed()结束

 //实现documentlistener接口中的方法(与撤销操作有关)
 public void removeupdate(documentevent e)
 { editmenu_undo.setenabled(true);
 }
 public void insertupdate(documentevent e)
 { editmenu_undo.setenabled(true);
 }
 public void changedupdate(documentevent e)
 { editmenu_undo.setenabled(true);
 }//documentlistener结束

 //实现接口undoableeditlistener的类undohandler(与撤销操作有关)
 class undohandler implements undoableeditlistener
 { public void undoableedithappened(undoableeditevent uee)
 { undo.addedit(uee.getedit());
 }
 }

 //main函数开始
 public static void main(string args[])
 { notepad notepad=new notepad();
 notepad.setdefaultcloseoperation(jframe.exit_on_close);//使用 system exit 方法退出应用程序
 }//main函数结束
}