FileUpdater.cs

   1 //Widgit is free software; you can redistribute it and/or modify
   2 //it under the terms of the GNU General Public License as published by
   3 //the Free Software Foundation; either version 2 of the License, or
   4 //(at your option) any later version.
   5
   6 //Widgit is distributed in the hope that it will be useful,
   7 //but WITHOUT ANY WARRANTY; without even the implied warranty of
   8 //MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   9 //GNU General Public License for more details.
  10
  11 //You should have received a copy of the GNU General Public License
  12 //along with Widgit; if not, write to the Free Software
  13 //Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USAusing System;
  14
  15 using System;
  16 using System.Collections.Generic;
  17 using System.Text;
  18 using Git;
  19
  20 namespace Widgit
  21 {
  22     using FilesList = List<Git.File>;
  23
  24     public class FilesUpdatedEvent : EventArgs
  25     {
  26         public FilesUpdatedEvent(FilesList files)
  27         {
  28             m_files = new FilesList(files);
  29         }
  30         protected FilesList m_files;
  31         public FilesList FilesList { get { return new FilesList(m_files); } }
  32     }
  33
  34     public delegate void FileUpdatedHandler(FileUpdater sender, FilesUpdatedEvent evt);
  35
  36     public class FileUpdater
  37     {
  38         public event FileUpdatedHandler FilesUpdated;
  39
  40         Prefs m_prefs;
  41
  42         protected Dictionary<IFileOperations, ISelectable> m_EventSourcesToSelectables = new Dictionary<IFileOperations,ISelectable>();
  43         public ISelectable this[IFileOperations o]
  44         {
  45             get { return m_EventSourcesToSelectables[o]; }
  46             set
  47             {
  48                 if (null == value)
  49                 {
  50                     o.Add -= OnAddFiles;
  51                     o.Copy -= OnCopyFiles;
  52                     o.Delete -= OnDeleteFiles;
  53                     o.RenameOrMove -= OnMoveFiles;
  54                     o.Revert -= OnRevertFiles;
  55                     o.DiffHead -= OnDiffFile;
  56                     o.DiffOther -= OnDiffHistoryFile;
  57                     o.View -= OnViewFile;
  58                     o.ViewPrevious -= OnViewPreviousFile;
  59                     m_EventSourcesToSelectables.Remove(o);
  60                 }
  61                 else
  62                 {
  63                     m_EventSourcesToSelectables[o] = value;
  64                     o.Add += OnAddFiles;
  65                     o.Copy += OnCopyFiles;
  66                     o.Delete += OnDeleteFiles;
  67                     o.RenameOrMove += OnMoveFiles;
  68                     o.Revert += OnRevertFiles;
  69                     o.DiffHead += OnDiffFile;
  70                     o.DiffOther += OnDiffHistoryFile;
  71                     o.View += OnViewFile;
  72                     o.ViewPrevious += OnViewPreviousFile;
  73                 }
  74             }
  75         }
  76
  77
  78         Repo m_currentRepo;
  79
  80         internal FileUpdater(Prefs prefs)
  81         {
  82             m_prefs = prefs;
  83         }
  84
  85         public void AddEventSource(IFileOperations f, ISelectable s)
  86         {
  87             m_EventSourcesToSelectables[f] = s;
  88             f.Add += OnAddFiles;
  89             f.Copy += OnCopyFiles;
  90             f.Delete += OnDeleteFiles;
  91             f.RenameOrMove += OnMoveFiles;
  92             f.Revert += OnRevertFiles;
  93         }
  94
  95         public void SetRepo(Repo repo)
  96         {
  97             m_currentRepo = repo;
  98         }
  99
 100         public bool AddFiles(FilesList files)
 101         {
 102             List<string> paths = MakePathsList(files);
 103             FilesList updatedFiles;
 104             if (m_currentRepo.Add(paths, out updatedFiles) && files.Count > 0)
 105             {
 106                 OnFileUpdated(new FilesUpdatedEvent(updatedFiles));
 107             }
 108             return true;
 109         }
 110
 111         public bool DeleteFiles(FilesList files)
 112         {
 113             List<string> paths = MakePathsList(files);
 114             FilesList updatedFiles;
 115             if (m_currentRepo.Remove(paths, out updatedFiles) && files.Count > 0)
 116             {
 117                 OnFileUpdated(new FilesUpdatedEvent(updatedFiles));
 118             }
 119             return true;
 120         }
 121
 122         public bool RevertFiles(FilesList files)
 123         {
 124             List<string> paths = MakePathsList(files);
 125             FilesList updatedFiles;
 126             if (m_currentRepo.Revert(paths, out updatedFiles) && files.Count > 0)
 127             {
 128                 OnFileUpdated(new FilesUpdatedEvent(updatedFiles));
 129             }
 130             return true;
 131         }
 132
 133         private static List<string> MakePathsList(FilesList files)
 134         {
 135             List<string> paths = new List<string>();
 136             foreach (File f in files)
 137             {
 138                 if (f.RelativePath.Length > 0)
 139                 {
 140                     paths.Add(f.PathWithName);
 141                 }
 142                 else
 143                 {
 144                     paths.Add(f.Name);
 145                 }
 146             }
 147             return paths;
 148         }
 149
 150         protected void OnFileUpdated(FilesUpdatedEvent e)
 151         {
 152             if (FilesUpdated != null)
 153             {
 154                 FilesUpdated(this, e);
 155             }
 156         }
 157
 158         protected void OnAddFiles(object sender, EventArgs e)
 159         {
 160             ISelectable s = m_EventSourcesToSelectables[(IFileOperations)sender];
 161             AddFiles(s.GetSelected());
 162         }
 163
 164         protected void OnDeleteFiles(object sender, EventArgs e)
 165         {
 166             ISelectable s = m_EventSourcesToSelectables[(IFileOperations)sender];
 167             DeleteFiles (s.GetSelected());
 168         }
 169
 170         protected void OnRevertFiles(object sender, EventArgs e)
 171         {
 172             ISelectable s = m_EventSourcesToSelectables[(IFileOperations)sender];
 173             RevertFiles(s.GetSelected());
 174         }
 175
 176         protected void OnViewFile(object sender, EventArgs e)
 177         {
 178             ISelectable s = m_EventSourcesToSelectables[(IFileOperations)sender];
 179             foreach (File f in s.GetSelected())
 180             {
 181                 string path = SerializeRevision(f, null);
 182
 183                 if (String.IsNullOrEmpty(m_prefs.ViewerApp))
 184                 {
 185                     System.Diagnostics.ProcessStartInfo si = new System.Diagnostics.ProcessStartInfo();
 186                     si.FileName = path;
 187                     si.UseShellExecute = true;
 188                     System.Console.WriteLine(si.FileName + " " + si.Arguments);
 189                     System.Diagnostics.Process p = new System.Diagnostics.Process();
 190                     p.StartInfo = si;
 191                     p.Start();
 192                 }
 193                 else
 194                 {
 195                     LaunchApp(m_prefs.ViewerApp, m_prefs.ViewerArgs, path, "", "", "");
 196                 }
 197             }
 198         }
 199
 200         protected void OnViewPreviousFile(object sender, EventArgs e)
 201         {
 202             ISelectable s = m_EventSourcesToSelectables[(IFileOperations)sender];
 203             RevertFiles(s.GetSelected());
 204         }
 205
 206         protected void OnDiffFile(object sender, EventArgs e)
 207         {
 208             ISelectable s = m_EventSourcesToSelectables[(IFileOperations)sender];
 209             if (String.IsNullOrEmpty(m_prefs.DiffApp))
 210             {
 211                 return;
 212             }
 213             foreach (File f in s.GetSelected())
 214             {
 215                 Diff(f, null, f, "HEAD");
 216             }
 217         }
 218
 219         protected void OnDiffHistoryFile(object sender, EventArgs e)
 220         {
 221             ISelectable s = m_EventSourcesToSelectables[(IFileOperations)sender];
 222             if (String.IsNullOrEmpty(m_prefs.DiffApp))
 223             {
 224                 return;
 225             }
 226
 227             List<Git.File> files = s.GetSelected();
 228             if (files.Count < 0)
 229             {
 230                 return;
 231             }
 232             List<string> paths = new List<string>();
 233             foreach (File f in files)
 234             {
 235                 paths.Add(f.PathWithName);
 236             }
 237             RevisionChooser c = new RevisionChooser();
 238             string commitish = c.Choose(m_currentRepo, paths);
 239             if (null == commitish)
 240             {
 241                 return;
 242             }
 243             foreach (File f in files)
 244             {
 245                 Diff(f, null, f, commitish);
 246             }
 247         }
 248
 249
 250         private string ReplaceOrAppend(string orig, string toReplace, string replaceWith)
 251         {
 252             if (orig.IndexOf(toReplace) < 0)
 253             {
 254                 orig += " \"" + replaceWith + "\"";
 255             }
 256             else
 257             {
 258                 orig = orig.Replace("[File]", "\"" + replaceWith + "\"");
 259             }
 260             return orig;
 261         }
 262
 263         protected string SerializeRevision(File f, string commitish)
 264         {
 265             string contents;
 266             if (String.IsNullOrEmpty(commitish))
 267             {
 268                 string nativePath = f.PathWithName.Replace(Repo.DirectorySeparator,
 269                                                             System.IO.Path.DirectorySeparatorChar.ToString());
 270                 nativePath = m_currentRepo.Path + System.IO.Path.DirectorySeparatorChar + nativePath;
 271                 return nativePath;
 272             }
 273             if (!f.GetRevision(commitish, out contents))
 274             {
 275                 return null;
 276             }
 277             string tmpFileName = System.IO.Path.GetTempFileName();
 278             System.IO.StreamWriter writer = new System.IO.StreamWriter(tmpFileName);
 279             writer.Write(contents);
 280             writer.Close();
 281             return tmpFileName;
 282         }
 283
 284         protected bool Diff(File file1, string commitish1, File file2, string commitish2)
 285         {
 286             if (null == file2)
 287             {
 288                 file2 = file1;
 289             }
 290
 291             string nativePath1 = SerializeRevision(file1, commitish1);
 292             if (null == nativePath1)
 293             {
 294                 return false;
 295             }
 296
 297             string nativePath2 = SerializeRevision(file2, commitish2);
 298             if (null == nativePath2)
 299             {
 300                 return false;
 301             }
 302             return LaunchApp(m_prefs.DiffApp, m_prefs.DiffArgs, "", nativePath2, nativePath1, "");
 303         }
 304
 305         protected bool LaunchApp(string execPath, string args, string file, string yours, string theirs, string target)
 306         {
 307             System.Diagnostics.ProcessStartInfo si = new System.Diagnostics.ProcessStartInfo();
 308             si.FileName = execPath;
 309             args = ReplaceOrAppend(args, "[File]", file);
 310             args = ReplaceOrAppend(args, "[Theirs]", theirs);
 311             args = ReplaceOrAppend(args, "[Yours]", yours);
 312             args = ReplaceOrAppend(args, "[Target]", target);
 313             si.Arguments = args;
 314             System.Console.WriteLine(si.FileName + " " + si.Arguments);
 315             System.Diagnostics.Process p = new System.Diagnostics.Process();
 316             p.StartInfo = si;
 317             p.Start();
 318             return true;
 319         }
 320
 321         protected void OnCopyFiles(object sender, EventArgs e)
 322         {
 323             //ISelectable s = m_EventSourcesToSelectables[sender];
 324             //CopyFiles(s.GetSelected());
 325         }
 326
 327         protected void OnMoveFiles(object sender, EventArgs e)
 328         {
 329             //ISelectable s = m_EventSourcesToSelectables[sender];
 330             //RevertFiles(s.GetSelected()); ;
 331         }
 332     }
 333 }