上次的文章发了就等到了一个面试机会,还没成就来北京了上了一个.net培训班。这个是这里老师安排的作业,让用.netAJAX实现的,想了想觉得那ExtJS+XML写可能更好这个东西就出来,主要思想是用ExtJS实现前台的UI,然后用AJAX方式实现和服务器的信息交互,这里没有用到一下ASP.NET下的AJAX实现,就是用的ExtJS自己的AJAX实现。主要是因为效率的考虑,再有就是ExtJS构建的页面基本上觉得就没有使用其他AJAX技术的必要了,他的页面已经没有刷新了,要的就是数据而已,数据是通过一般处理程序生产XML实现的。下面就是具体的实现方式,和遇到的一些问题。

ExtJS我也是第一次使用,我希望我的经历也可以给和我一样初学ExtJS的朋友一些提示(毕竟当时走了不少弯路)。

ExtJS 和Jquery很像大部分的功能实现都是在初始化的时候实现的。基本没有是用一个input调用的。个人觉得这个比JQuery做的还有很,比如 JQuery的AJAX还可以写在input里面,但是ExtJS你会发现你要是这么写了,其他的东西就很难编写了。Ext还像C#一样实现了:属性,方法,甚至实现了事件的机制。大部分ExtJS控件都有一个handler可以通过配置它来出发实现一些事件。而在定义ExtJS控件的时候有点像定义 ASP.NET控件一样有一些配置的信息跟在其后,看了ExtJS以后举得这个东西可以说是完全的JS的面向对象了,强悍强悍。

下面我就介绍一下我这里web文件管理系统了

首先是一些文件压缩,拷贝等的BLL这里就不做太多的介绍了,就是一些System.File.IO的一些为对文件进行操作的类,已实现前台的一些功能。

用于文件描述的类

文件描述类
  1. \\枚举类型描述文件是文件还是文件夹   
  2. public enum FileType { File, Folder };
  3. \\文件描述类
  4. public class DealFiles
  5. {
  6.     public string FileName { get; set; }
  7.     public FileType fileType { get; set; }
  8.     public DealFiles(string Name, FileType Type)
  9.     {
  10.        
  11.         FileName = Name;
  12.         fileType = Type;
  13.     }
  14.     public DealFiles()
  15.     { }
复制代码
IO文件操作类

FileManager.cs
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Web;
  4. using System.IO;

  5. /// <summary>
  6. ///realize file manager handler (new folder,new file,copy,paste,del,move,rename,cut)
  7. /// </summary>
  8. namespace DragonJ
  9. {
  10.     public class FileManager
  11.     {
  12.         public FileManager()
  13.         {
  14.             //
  15.             //TODO: 在此处添加构造函数逻辑
  16.             //
  17.         }
  18.         public string path { get; set; }
  19.         public FileManager(string ParentPath)
  20.         {
  21.             this.path = ParentPath;
  22.         }
  23.         /// <summary>
  24.         /// 复制文件和文件夹(外部访问)
  25.         /// </summary>
  26.         /// <param name="list"></param>
  27.         /// <param name="comedir"></param>
  28.         /// <param name="todir"></param>
  29.         /// <returns></returns>
  30.         public bool CopyFiles(List<DealFiles> list, string comedir, string todir)
  31.         {
  32.             bool ret = false;
  33.             try
  34.             {
  35.                 foreach (DealFiles i in list)
  36.                 {
  37.                     if (i.fileType == FileType.Folder)
  38.                     {
  39.                         FolderCopy(i.FileName, comedir, todir);
  40.                     }
  41.                     else
  42.                     {
  43.                         DataCopy(i.FileName, comedir, todir);
  44.                     }
  45.                 }
  46.                 ret = true;
  47.             }
  48.             catch (Exception e)
  49.             {

  50.                 throw e;
  51.             }
  52.             return ret;
  53.         }
  54.         /// <summary>
  55.         /// 复制文件到指定目录
  56.         /// </summary>
  57.         /// <param name="filename"></param>
  58.         /// <param name="comedir"></param>
  59.         /// <param name="todir"></param>
  60.         /// <returns></returns>
  61.         private bool DataCopy(string filename, string comedir, string todir)
  62.         {
  63.             bool ret = false;
  64.             string new_filename;
  65.             if (comedir == todir)
  66.             {
  67.                 new_filename = "复制" + filename;
  68.             }
  69.             else
  70.             {
  71.                 new_filename = filename;
  72.             }
  73.             try
  74.             {
  75.                 File.Copy(Path.Combine(comedir, filename), Path.Combine(todir, filename));
  76.                 ret = true;
  77.             }
  78.             catch (Exception e)
  79.             {
  80.                 throw e;
  81.             }
  82.             return ret;
  83.         }

  84.         /// <summary>
  85.         /// 复制文件夹到指定目录
  86.         /// </summary>
  87.         /// <param name="folderName"></param>
  88.         /// <param name="comedir"></param>
  89.         /// <param name="todir"></param>
  90.         /// <returns></returns>
  91.         private bool FolderCopy(string folderName, string comedir, string todir)
  92.         {
  93.             bool ret = false;
  94.             string new_folderName;
  95.             if (comedir == todir)
  96.             {
  97.                 new_folderName = "复制" + folderName;
  98.             }
  99.             else
  100.             {
  101.                 new_folderName = folderName;
  102.             }
  103.             try
  104.             {
  105.                 if (Directory.Exists(Path.Combine(comedir, folderName)))
  106.                 {
  107.                     string[] files = Directory.GetFiles(Path.Combine(comedir, folderName));
  108.                     Directory.CreateDirectory(Path.Combine(todir, folderName));
  109.                     foreach (string file in files)
  110.                     {
  111.                         DataCopy(Path.GetFileName(file), Path.Combine(comedir, folderName), Path.Combine(todir, folderName));
  112.                     }
  113.                     //这里的没有向zip类中写的父目录不断更改,看看是否好使
  114.                     string[] dirs = Directory.GetDirectories(Path.Combine(comedir, folderName));
  115.                     foreach (string dir in dirs)
  116.                     {
  117.                         if (!FolderCopy(Path.GetFileName(dir), Path.Combine(comedir, folderName), Path.Combine(todir, folderName)))
  118.                         {
  119.                             return false;
  120.                         }
  121.                     }
  122.                     ret = true;
  123.                 }
  124.             }
  125.             catch (Exception e)
  126.             {
  127.                 throw e;
  128.             }
  129.             return ret;
  130.         }
  131.         /// <summary>
  132.         /// 删除文件和文件夹(外部访问)
  133.         /// </summary>
  134.         /// <param name="list"></param>
  135.         /// <param name="dir"></param>
  136.         /// <returns></returns>
  137.         public bool DelFiles(List<DealFiles> list, string dir)
  138.         {
  139.             bool ret = false;
  140.             try
  141.             {
  142.                 foreach (DealFiles i in list)
  143.                 {
  144.                     if (i.fileType == FileType.Folder)
  145.                     {
  146.                         FolderDel(Path.Combine(dir, i.FileName));
  147.                     }
  148.                     else
  149.                     {
  150.                         DataDel(i.FileName, dir);
  151.                     }
  152.                 }
  153.                 ret = true;
  154.             }
  155.             catch (Exception e)
  156.             {

  157.                 throw e;
  158.             }

  159.             return ret;
  160.         }
  161.         /// <summary>
  162.         /// 删除文件
  163.         /// </summary>
  164.         /// <param name="filename"></param>
  165.         /// <param name="dir"></param>
  166.         /// <returns></returns>
  167.         private bool DataDel(string filename, string dir)
  168.         {
  169.             bool ret = false;

  170.             try
  171.             {
  172.                 File.Delete(Path.Combine(dir, filename));
  173.                 ret = true;
  174.             }
  175.             catch (Exception e)
  176.             {
  177.                 throw e;
  178.             }
  179.             return ret;
  180.         }
  181.         /// <summary>
  182.         /// 删除文件夹(包括其子目录)
  183.         /// </summary>
  184.         /// <param name="dir"></param>
  185.         /// <returns></returns>
  186.         private bool FolderDel(string dir)
  187.         {
  188.             bool ret = false;
  189.             try
  190.             {
  191.                 Directory.Delete(dir, true);
  192.                 ret = true;
  193.             }
  194.             catch (Exception e)
  195.             {

  196.                 throw e;
  197.             }
  198.             return ret;
  199.         }
  200.         /// <summary>
  201.         /// 移动文件和文件夹
  202.         /// </summary>
  203.         /// <param name="filename"></param>
  204.         /// <param name="comedir"></param>
  205.         /// <param name="todir"></param>
  206.         /// <returns></returns>
  207.         public bool MoveFiles(List<DealFiles> list, string comedir, string todir)
  208.         {
  209.             bool ret = false;
  210.             try
  211.             {
  212.                 CopyFiles(list, comedir, todir);
  213.                 DelFiles(list, comedir);
  214.                 ret = true;
  215.             }
  216.             catch (Exception e)
  217.             {
  218.                 throw e;
  219.             }
  220.             return ret;
  221.         }
  222.         /// <summary>
  223.         /// 创建文件夹
  224.         /// </summary>
  225.         /// <param name="folderName"></param>
  226.         /// <returns></returns>
  227.         public bool CreatFolder(string folderName)
  228.         {
  229.             bool ret = false;
  230.             try
  231.             {
  232.                 Directory.CreateDirectory(Path.Combine(path, folderName));
  233.                 ret = true;
  234.             }
  235.             catch (Exception e)
  236.             {
  237.                 throw e;
  238.             }
  239.             return ret;
  240.         }
  241.         /// <summary>
  242.         /// 创建文件
  243.         /// </summary>
  244.         /// <param name="fileName"></param>
  245.         /// <returns></returns>
  246.         public bool CreatFile(string fileName, string text)
  247.         {
  248.             bool ret = false;
  249.             System.IO.FileStream fs = null;
  250.             try
  251.             {
  252.                 fs = File.Open(Path.Combine(path, fileName), FileMode.CreateNew, FileAccess.ReadWrite);
  253.                 byte[] butter = System.Text.Encoding.Default.GetBytes(text);
  254.                 byte[] but = new byte[16];

  255.                 fs.Write(butter, 0, butter.Length);
  256.                 ret = true;
  257.             }
  258.             catch (Exception e)
  259.             {

  260.                 throw e;
  261.             }
  262.             finally
  263.             {
  264.                 fs.Dispose();
  265.             }
  266.             return ret;
  267.         }
  268.         public System.Text.StringBuilder ReadFile(string fileName)
  269.         {
  270.             System.Text.StringBuilder str = new System.Text.StringBuilder();
  271.             System.IO.FileStream fs = null;
  272.             try
  273.             {

  274.                 fs = File.Open(Path.Combine(path, fileName), FileMode.Open);
  275.                 int length = 0;
  276.                 System.Text.Encoding GB = System.Text.Encoding.GetEncoding(20936);
  277.                 byte[] but = new byte[16];
  278.                 while ((length = fs.Read(but, 0, but.Length)) > 0)
  279.                 {
  280.                     str.Append(GB.GetString(but));
  281.                 }
  282.             }
  283.             catch (Exception e)
  284.             {
  285.                 throw e;
  286.             }
  287.             finally
  288.             {
  289.                 fs.Dispose();
  290.             }
  291.             return str;
  292.         }

  293.     }
复制代码
文件压缩类

Zip.cs
  1.     public class ZipClass
  2.     {
  3.         ///
  4.         /// 递归压缩文件夹方法
  5.         ///
  6.         ///

  7.         private static bool ZipFileDictory(string FolderToZip, ZipOutputStream s, string ParentFolderName, string RootFolder)
  8.         {
  9.             bool res = true;
  10.             string[] folders, filenames;
  11.             ZipEntry entry = null;
  12.             FileStream fs = null;
  13.             Crc32 crc = new Crc32();

  14.             try
  15.             {

  16.                 //创建当前文件夹
  17.                 //entry = new ZipEntry(Path.Combine(ParentFolderName, Path.GetFileName(FolderToZip) + "\\")); //加上 “/” 才会当成是文件夹创建
  18.                 //s.PutNextEntry(entry);
  19.                 //s.Flush();


  20.                 //先压缩文件,再递归压缩文件夹

  21.                 filenames = Directory.GetFiles(Path.Combine(ParentFolderName, FolderToZip));
  22.                 foreach (string file in filenames)
  23.                 {
  24.                     //打开压缩文件
  25.                     fs = File.OpenRead(file);

  26.                     byte[] buffer = new byte[fs.Length];
  27.                     fs.Read(buffer, 0, buffer.Length);
  28.                     string URL = file.Replace(RootFolder+@"\", "");
  29.                     entry = new ZipEntry(URL);
  30.                     entry.DateTime = DateTime.Now;
  31.                     entry.Size = fs.Length;
  32.                     fs.Close();

  33.                     crc.Reset();
  34.                     crc.Update(buffer);

  35.                     entry.Crc = crc.Value;

  36.                     s.PutNextEntry(entry);

  37.                     s.Write(buffer, 0, buffer.Length);
  38.                 }
  39.             }
  40.             catch
  41.             {
  42.                 res = false;
  43.             }
  44.             finally
  45.             {
  46.                 if (fs != null)
  47.                 {
  48.                     fs.Close();
  49.                     fs = null;
  50.                 }
  51.                 if (entry != null)
  52.                 {
  53.                     entry = null;
  54.                 }
  55.                 GC.Collect();
  56.                 GC.Collect(1);
  57.             }


  58.             folders = Directory.GetDirectories(Path.Combine(ParentFolderName, FolderToZip));
  59.             foreach (string folder in folders)
  60.             {
  61.                 if (!ZipFileDictory(Path.GetFileName(folder), s, Path.Combine(ParentFolderName, FolderToZip),RootFolder))
  62.                 {
  63.                     return false;
  64.                 }
  65.             }

  66.             return res;
  67.         }


  68.         ///
  69.         /// 压缩文件
  70.         ///
  71.         /// 要进行压缩的文件名
  72.         /// 压缩后生成的压缩文件名
  73.         ///
  74.         private static bool ZipFile(string FileToZip, ZipOutputStream s, string ParentFolderName, string RootFolder)
  75.         {
  76.             //如果文件没有找到,则报错
  77.             System.IO.DirectoryInfo di = new DirectoryInfo(ParentFolderName);
  78.             if (!File.Exists(System.IO.Path.Combine(ParentFolderName, FileToZip)))
  79.             {
  80.                 throw new System.IO.FileNotFoundException("指定要压缩的文件: " + FileToZip + " 不存在!");
  81.             }
  82.             FileStream fs = null;
  83.             ZipEntry ZipEntry = null;

  84.             bool res = true;
  85.             try
  86.             {
  87.                 //打开压缩文件
  88.                 fs = File.OpenRead(Path.Combine(ParentFolderName,FileToZip));
  89.                 byte[] buffer = new byte[fs.Length];
  90.                 fs.Read(buffer, 0, buffer.Length);
  91.                
  92.                 string URL=Path.Combine(ParentFolderName.Replace(RootFolder,""), FileToZip);
  93.                 ZipEntry = new ZipEntry(URL);
  94.                 ZipEntry.DateTime = DateTime.Now;
  95.                 ZipEntry.Size = fs.Length;
  96.                 fs.Close();
  97.                 s.PutNextEntry(ZipEntry);
  98.                 s.Write(buffer, 0, buffer.Length);
  99.             }
  100.             catch
  101.             {
  102.                 res = false;
  103.             }
  104.             finally
  105.             {
  106.                 if (ZipEntry != null)
  107.                 {
  108.                     ZipEntry = null;
  109.                 }
  110.                 if (fs != null)
  111.                 {
  112.                     fs.Close();
  113.                     fs = null;
  114.                 }
  115.                 GC.Collect();
  116.                 GC.Collect(1);
  117.             }

  118.             return res;
  119.         }

  120.         ///
  121.         /// 压缩文件 和 文件夹
  122.         ///
  123.         /// 待压缩的文件或文件夹,全路径格式
  124.         /// 压缩后生成的压缩文件名,全路径格式
  125.         ///
  126.         public static bool Zip(List<DealFiles> FilesList, string ParentFolderName, string ZipFileName)
  127.         {
  128.             bool ret = true;
  129.             System.IO.DirectoryInfo di = new DirectoryInfo(ParentFolderName);
  130.             ZipOutputStream s = null;
  131.             if (di.Exists)
  132.             {
  133.                
  134.                 try
  135.                 {
  136.                     s = new ZipOutputStream(File.Create(System.IO.Path.Combine(ParentFolderName, ZipFileName + ".zip")));
  137.                     s.SetLevel(6);
  138.                     foreach (DealFiles i in FilesList)
  139.                     {
  140.                         if (i.fileType == FileType.Folder)
  141.                         {
  142.                             ZipFileDictory(i.FileName, s, ParentFolderName, ParentFolderName);
  143.                         }
  144.                         else
  145.                         {
  146.                             ZipFile(i.FileName, s, ParentFolderName, ParentFolderName);
  147.                         }
  148.                     }
  149.                 }
  150.                 catch (FileNotFoundException e)
  151.                 {
  152.                     ret = false;
  153.                     throw e;
  154.                 }
  155.                 catch (FileLoadException e)
  156.                 {
  157.                     ret = false;
  158.                     throw e;
  159.                 }
  160.                 catch (FieldAccessException e)
  161.                 {
  162.                     ret = false;
  163.                     throw e;
  164.                 }
  165.                 finally
  166.                 {
  167.                     if (s != null)
  168.                     {
  169.                         s.Close();
  170.                         s = null;
  171.                     }
  172.                 }
  173.             }
  174.             else
  175.             {

  176.             }


  177.             return ret;
  178.         }
复制代码
文件解压缩类

UnZip.cs
  1. public class UnZipClass
  2.     {
  3.         ///
  4.         /// 解压功能(解压压缩文件到指定目录)
  5.         ///
  6.         /// 待解压的文件
  7.         /// 指定解压目标目录
  8.         public static bool UnZip(string FileToUpZip, string ZipedFolder)
  9.         {
  10.             bool ret = false;
  11.             if (!File.Exists(FileToUpZip))
  12.             {
  13.                 return false;
  14.             }
  15.             else
  16.             { }

  17.             if (!Directory.Exists(ZipedFolder))
  18.             {
  19.                 Directory.CreateDirectory(ZipedFolder);
  20.             }
  21.             else
  22.             { }

  23.             ZipInputStream s = null;
  24.             ZipEntry theEntry = null;

  25.             string fileName;
  26.             FileStream streamWriter = null;
  27.             try
  28.             {
  29.                 s = new ZipInputStream(File.OpenRead(FileToUpZip));
  30.                 while ((theEntry = s.GetNextEntry()) != null)
  31.                 {
  32.                     if (theEntry.Name != String.Empty)
  33.                     {
  34.                         fileName = Path.Combine(ZipedFolder, theEntry.Name);
  35.                         ///判断文件路径是否是文件夹
  36.                         if (theEntry.Name.IndexOf("/") > 0 || theEntry.Name.IndexOf("\\")>0)
  37.                         {
  38.                             CreateFolderForUnZip(fileName);
  39.                         }

  40.                         streamWriter = File.Create(fileName);
  41.                         int size = 2048;
  42.                         byte[] data = new byte[2048];
  43.                         while (true)
  44.                         {
  45.                             size = s.Read(data, 0, data.Length);
  46.                             if (size > 0)
  47.                             {
  48.                                 streamWriter.Write(data, 0, size);
  49.                             }
  50.                             else
  51.                             {
  52.                                 break;
  53.                             }
  54.                         }
  55.                     }
  56.                 }
  57.                 ret = true;
  58.             }
  59.             finally
  60.             {
  61.                 if (streamWriter != null)
  62.                 {
  63.                     streamWriter.Close();
  64.                     streamWriter = null;
  65.                 }
  66.                 if (theEntry != null)
  67.                 {
  68.                     theEntry = null;
  69.                 }
  70.                 if (s != null)
  71.                 {
  72.                     s.Close();
  73.                     s = null;
  74.                 }
  75.                 GC.Collect();
  76.                 GC.Collect(1);
  77.             }
  78.             return ret;
  79.         }
  80.         //递归方式创建文件夹
  81.         private static void CreateFolderForUnZip(string fileName)
  82.         {
  83.             if (!Directory.Exists(Path.GetDirectoryName(fileName)))
  84.             {
  85.                 Directory.CreateDirectory(Path.GetDirectoryName(fileName));
  86.                 CreateFolderForUnZip(Path.GetDirectoryName(fileName));
  87.             }
  88.         }
复制代码
看了这些大家一定发现上面操作的类都是用的一个List实现的这是为了,这是为了让ExtJS实现多文件选择而设计的,Ext会用AJAX回传一个选择文件的列表给服务器,然后转化成这里用到的List进行操作。

下面这个类是用来实现ExtJS的文件管理导航的即文件夹的的前进,后退,向上。这个是用的一个的栈实现的,原理我就不说了,说栈大家估计就明白了,本来是想直接用JS实现的,但是有想起来了序列化,正好没有什么地方联系就用了序列化实现的这个功能,这个功能是仿照的ViewState的原理实现的,在每次点击页面的时候会产生一个AJAX回传,把数据给服务器,服务器将数据放在一下这个类中,然后经过序列化成Base64在传给页面的一个隐藏字段,这个字段在回传的时候一起回传在服务器上经过反序列化再生成这个类的一个实例。

PageManager.cs
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Web;

  4. /// <summary>
  5. ///realize web page manager PgUp PgDn Parenet refurbish
  6. /// </summary>
  7. namespace DragonJ
  8. {
  9.     [System.Serializable]
  10.     public class PageManager
  11.     {
  12.         private Stack<string> forwardURL = new Stack<string>(5);
  13.         private Stack<string> backURL = new Stack<string>(5);
  14.         //public string path
  15.         //{
  16.         //    get { return path; }
  17.         //    set { path = value; }
  18.         //}
  19.         public string path { get; set; }
  20.         public PageManager(string Path)
  21.         {
  22.             //
  23.             //TODO: 在此处添加构造函数逻辑
  24.             //
  25.             this.path = Path;
  26.         }
  27.        
  28.         public void enterNewPage(string urlCome)
  29.         {
  30.             backURL.Push(path);
  31.             this.path = urlCome;
  32.         }
  33.         public string enterForward()
  34.         {
  35.            
  36.             string url=string.Empty;
  37.             if (forwardURL.Count != 0)
  38.             {
  39.                 string urlCome = this.path;
  40.                 url = forwardURL.Pop() as string;
  41.                 backURL.Push(urlCome);
  42.                 this.path = url;
  43.             }
  44.             return url;
  45.         }
  46.         public string enterBack()
  47.         {
  48.             string url = string.Empty;
  49.             if (backURL.Count != 0)
  50.             {
  51.                 string urlCome = this.path;
  52.                 url = backURL.Pop() as string;
  53.                 forwardURL.Push(urlCome);
  54.                 this.path = url;
  55.             }
  56.             return url;
  57.         }
  58.         public string upFolder()
  59.         {
  60.            
  61.             string url = string.Empty;
  62.             string urlCome = this.path;
  63.             url=System.IO.Path.GetDirectoryName(urlCome);
  64.             backURL.Push(urlCome);
  65.             this.path = url;
  66.             return url;
  67.         }
  68.    
  69.     }
复制代码
用于功能的类现在已经写完了,现在就让我们一起来来用ExtJS来实现这些功能,在这之前我们介绍一下ExtJS的基本用法,ExtJS自己写了不少控件,这些控件就是我们要用来搭建我们UI的,这些控件都是要在页面初始化的时候配置的,ExtJS有一个Ext.onReady事件,在这里面加载你要的控件配置他们就可以等到效果了。下面是一个简单的GridPanel配置的例子。
  1. Ext.onReady(function() {
  2.     grid = new Ext.grid.GridPanel({

  3.         id: "grid_view",
  4.         title: "文件管理",
  5.         width: 800,
  6.         height: 400,
  7.         region: "east",
  8.         sm: sm,
  9.         cm: cm,
  10.         renderTo: document.body,
  11.         frame: true,
  12.         store: store
  13. });
复制代码
大家可以看到这里的写发用的是JOSN,个人觉得JOSN是个好东西能传数据(拿JOSN传数据要比XML省空间),又能用来实现JS的面向对象。大家看见了ExtJS就是用JOSN实现面向对象的写代码方式,而且配合JS的特点和JOSN你的JS代码就可以实现方法了,因为在JS里面几乎所有的东西都可以看成变量,函数也不例外,这只要在定义一个名值对在值的里面写一个函数就能轻松的实现一个带方法的类了。

在ExtJS里面也是用的这种方式来是实现的,很多控件都有一个handler或是callback属性,有的有listener这些后面都是跟的一个函数,来加载事件。

下面就是我这个系统里面GridPanel的完整配置。
  1. Ext.onReady(function() {
  2.     grid = new Ext.grid.GridPanel({

  3.         id: "grid_view",
  4.         title: "文件管理",
  5.         width: 800,
  6.         height: 400,
  7.         region: "east",
  8.         sm: sm,//加载选择模板
  9.         cm: cm,//加载模板列
  10.         //这个是底部工具条
  11.         bbar: [
  12.         { xtype: "field",
  13.             width: 200,
  14.             handler: function() { }
  15.         }, '-', {
  16.             text: "前往",
  17.             handler: function() {
  18.                 EnterPage(grid.getBottomToolbar().items.item(0).getValue());
  19.             }
  20. }],
  21.             //顶部工具条
  22.             tbar: [{
  23.                 text: "后退",

  24.                 handler: function() { DealPage("back"); }

  25.             }, '-', {
  26.                 text: "前进",
  27.                 handler: function() { DealPage("forward"); }
  28.             }, '-', {
  29.                 text: "向上",
  30.                 handler: function() { DealPage("up"); }
  31.             }, '-', {
  32.                 text: "新建文件",
  33.                 handler: function() { NewFiles("NewFile"); }
  34.             }, '-', {
  35.                 text: "新建文件夹",
  36.                 handler: function() { NewFiles("NewFolder"); }
  37.             }, '-', {
  38.                 text: "复制",
  39.                 handler: function() { Reg_Copy_Files(); }
  40.             }, '-', {
  41.                 text: "粘贴",
  42.                 handler: function() { PasteFiles(); }
  43.             }, '-', {
  44.                 text: "删除",
  45.                 handler: function() { DelFiles(); }
  46.             }, '-', {
  47.                 text: "移动",
  48.                 handler: function() { Reg_Move_Files(); }
  49.             }, '-', {
  50.                 text: "取消",
  51.                 disabled: true,
  52.                 handler: function() { Reset_RegDatas(); }
  53.             }, '-', {
  54.                 text: "压缩",
  55.                 handler: function() { ZipFiles(); }
  56.             }, '-', {
  57.                 text: "解压缩",
  58.                 handler: function() { UnZipFile(); }
  59. }],
  60.                 viewConfig: {
  61.                     forceFit: true
  62.                 },
  63.                 renderTo: document.body,//指定Grid记载到那个页面元素
  64.                 frame: true,
  65.                 store: store//加载数据源
  66.             });
  67.             grid.on("rowdblclick", rowdbClick);//添加行的双击事件
  68.             grid.on("rowcontextmenu", open_rowcontextmenu);//添加行的右键事件
  69.             grid.getBottomToolbar().items.item(0).setValue("D:\\");//初始化底部工具栏的路径信息
  70.         });
复制代码
基本页面上面的每个功能都是通过AJAX回传来实现的,这里没有应用.net的AJAX框架,就是用的ExtJS的AJAX回传技术。下面是一个AJAX回传的例子。
  1. Ext.Ajax.request({
  2.       url: "FileManager.ashx",
  3.       method: "Post",
  4.       params: { Path: SelectDataItems, Type: "Copy", Root: document.getElementById("Now_Path").value, FromRoot: fromURL },
  5.       callback: function(options, success, response) {
  6.                 window.alert(response.responseText);
  7.                 window.alert(response.responseText == "OK");
  8.                 if (success && response.responseText == "OK") {
  9.                         Ext.MessageBox.alert("文件操作提示", "拷贝数据成功");
  10.                         Rerender(document.getElementById("Now_Path").value);
  11.                     }
  12.                     else {
  13.                         Ext.MessageBox.alert("文件操作提示", "拷贝数据出错");
  14.                         Rerender(document.getElementById("Now_Path").value);
  15.                     }
  16.                     grid.getTopToolbar().items.item(10).enable();
  17.                     grid.getTopToolbar().items.item(18).enable();
  18.                 }
  19.             });
复制代码
url:要回传到的网址
method:回传的方式有GET,POST
params:回传的时候带了参数(以JOSN方式数据格式输入)
callback:AJAX回传后出触发事件

在callback事件中的函数有三个参数分别是
options:用来回传的参数
success:回传是否成功
response:这个就是关键了这是一个XMLHttpRequest类型的回传值,也就是说这个就是AJAX的回传结构。

不想把一个文章写的太长这样不好看,呵呵剩下具体功能还是写到会面的文章里了,这里说一下自己对ExtJS的编写代码的理解,因为ExtJS的文档不是很全,而且官方的文档是E文的所以刚刚开始的时候没有爱看,但是渐渐发现其实这个是最有用的,虽然上面没有多少例子,那个还是非常有用的,还有就是不要看中文的那个API文档用了以后才知道那个上面的东西不全!!!建议大家开始的时候看看别人的一些例子,然后就自己写个好玩的东东,不会了就去看API文档,文档的里面每项都有值的类型,如果那个项看不懂就去看看它的类型的文档。最后给出整个的ExtJS的界面源码

UI源码下载:
附件: 亲,您没有权限下载或查看附件喔:-) 试试登录注册吧!
TOP

学习一下,谢谢共享经验
TOP

回复 1# cobra 的帖子

支持顶顶!!!!!!!!!1
TOP

TOP

ok支持顶顶

支持顶顶
TOP

非常好的代码,感谢你的提供啊

非常好的代码,感谢你的提供啊,好人啊
TOP

支持下,正想找这样的例子
TOP

需要

需要类似的东西 看下
TOP

非常想看看
TOP

好东西

好东西!
TOP