예제 #1
0
        public bool EncrFilter(FSEntry entry)
        {
            string fileName = entry.RelativePath;

            if (string.Equals(fileName, HelixConsts.HeaderFileName))
            {
                return(false);
            }
            if (string.Equals(fileName, HelixConsts.SyncLogDirectory))
            {
                return(false);
            }
            if (fileName.StartsWith(HelixConsts.SyncLogDirectory + Path.DirectorySeparatorChar, StringComparison.Ordinal))
            {
                return(false);
            }
            if (Path.GetExtension(fileName) == HelixConsts.StagedHxExtention)
            {
                return(false);
            }
            if (Path.GetExtension(fileName) == HelixConsts.BackupExtention)
            {
                return(false);
            }
            if (entry.EntryType != FileEntryType.File)
            {
                return(false);
            }

            return(true);
        }
예제 #2
0
        public FSEntry Find(string path)
        {
            // good:  /foo/bar, /foo/bar/
            // bad:  foo, foo/bar, //foo/bar, /foo//bar, /foo/../foo/bar
            VirtualNode current = virtualFileSystem.RootNode;

            string[] elements = path.Split(PATH_SEPARATOR);

            foreach (string element in elements.Skip(1))
            {
                VirtualNode child = current.GetChild(element);
                if (child != null)
                {
                    current = child;
                }
                else
                {
                    return(null);
                }
            }

            FSEntry result = null;

            if (current.IsDirectory)
            {
                result = new SimpleDirectory(current);
            }
            else
            {
                result = new SimpleFile(current);
            }

            return(result);
        }
예제 #3
0
        private List <FSEntry> RecompressDir(string dir)
        {
            string[]       files   = Directory.GetFiles(dir);
            List <FSEntry> entries = new List <FSEntry>(files.Length);

            byte[] compBuffer = new byte[8192];

            foreach (string f in files)
            {
                FSEntry fe = new FSEntry();
                fe.tocEntry             = new TocEntry();
                fe.tocEntry.dateTime    = GetFileCreationTimeInSeconds(f);
                fe.tocEntry.flags       = TOCFlags_File;
                fe.tocEntry.offsetIndex = 0;
                fe.tocEntry.name        = new byte[25];
                fe.diskFile             = f;
                using (FileStream fs = new FileStream(f, FileMode.Open, FileAccess.Read))
                {
                    MemoryStream     ms    = new MemoryStream((int)fs.Length);
                    GZipOutputStream gzOut = new GZipOutputStream(ms);
                    gzOut.SetLevel(2);
                    StreamUtils.Copy(fs, gzOut, compBuffer);
                    byte[] compData = ms.GetBuffer();
                    Array.Resize(ref compData, (int)ms.Position);
                    fe.compressedFile = compData;
                }
                string gzName = Path.GetFileName(f) + ".gz";
                fe.name = gzName;
                entries.Add(fe);
            }
            return(entries);
        }
예제 #4
0
        public List <FSEntry> ScanAndCompress(string flatDir, bool recomp)
        {
            List <FixupPair> dirOffsetsToFixup = new List <FixupPair>();
            List <FSEntry>   entries           = ScanAndCompressDir(flatDir, dirOffsetsToFixup, recomp);

            if (entries.Count != 0)
            {
                // there is no .. entry at the start of the list
                entries.RemoveAt(0);
            }
            int runningIndex = 0;

            foreach (FixupPair pair in dirOffsetsToFixup)
            {
                bool isDotDotKey = pair.Key.name == "..";
                int  startIndex  = isDotDotKey ? 0 : runningIndex;
                int  i           = startIndex;
                for (; i < entries.Count; ++i)
                {
                    FSEntry listEntry = entries[i];
                    if (Object.ReferenceEquals(listEntry, pair.Value))
                    {
                        pair.Key.tocEntry.offsetIndex = (short)i;
                        break;
                    }
                }
                if (!isDotDotKey)
                {
                    runningIndex = i + 1;
                }
            }
            return(entries);
        }
예제 #5
0
        public SyncLogEntry CreateNewLogEntryFromDecrPath(string decrFileName)
        {
            FSEntry decrEntry = DecrDirectory.TryGetEntry(decrFileName);

            string  encrFileName = FileNameEncoder.EncodeName(decrFileName);
            FSEntry encrEntry    = EncrDirectory.TryGetEntry(encrFileName);

            return(new SyncLogEntry(decrEntry.EntryType, decrEntry.RelativePath, decrEntry.LastWriteTimeUtc, encrEntry.RelativePath, encrEntry.LastWriteTimeUtc));
        }
예제 #6
0
        static void ValidateBadPath(FileSystem fs, string path)
        {
            FSEntry fse = fs.Find(path);

            if (fse != null)
            {
                throw new Exception("Path: " + path + " invalid!");
            }
        }
예제 #7
0
        static void ValidatePath(FileSystem fs, string path)
        {
            FSEntry fse = fs.Find(path);

            if (fse == null || fse.FullPathName != path && (fse.FullPathName + "/") != path)
            {
                throw new Exception("Path: " + path + " invalid! Should have been valid..");
            }
        }
        private void LoadPasswordFile()
        {
            // Read all users from the password file

            // open if it exists
            Directory root  = filesystem.GetRootDirectory();
            FSEntry   entry = filesystem.Find("/" + passwordFileName);

            if (entry != null)
            {
                // Read contents
                File       pwfile = entry as File;
                FileStream stream = pwfile.Open();
                byte[]     bytes  = stream.Read(0, pwfile.Length);
                stream.Close();

                // convert to string
                string data = ASCIIEncoding.ASCII.GetString(bytes);

                // parse based on format below
                // userID;username;password;homedir;shell
                string[] rows = data.Split('\n');
                foreach (string row in rows)
                {
                    if (row.Length > 0)
                    {
                        string[] fields = row.Split(';');
                        if (fields.Length == 5)
                        {
                            User user = new User();
                            user.userID        = Convert.ToInt32(fields[0]);
                            user.userName      = fields[1];
                            user.password      = fields[2];
                            user.homeDirectory = fields[3];
                            user.shell         = fields[4];

                            usersById[user.userID] = user;

                            // Update UserID
                            if (user.userID >= nextUserID)
                            {
                                nextUserID = user.userID + 1;
                            }
                        }
                        else
                        {
                            throw new Exception("found malformed row in password file: " + row);
                        }
                    }
                }
            }
        }
예제 #9
0
        public bool DecrFilter(FSEntry entry)
        {
            string fileName = entry.RelativePath;

            if (string.Equals(fileName, HelixConsts.SyncLogDirectory))
            {
                return(false);
            }
            if (fileName.StartsWith(HelixConsts.SyncLogDirectory + HelixUtil.UniversalDirectorySeparatorChar, StringComparison.Ordinal))
            {
                return(false);
            }

            return(true);
        }
예제 #10
0
        public SyncLogEntry CreateEntryFromHeader(FileEntry decrFileInfo, FSEntry encrFileInfo)
        {
            if (decrFileInfo == null)
            {
                throw new ArgumentNullException(nameof(decrFileInfo));
            }
            if (encrFileInfo == null)
            {
                throw new ArgumentNullException(nameof(encrFileInfo));
            }

            SyncLogEntry entry = new SyncLogEntry(decrFileInfo.EntryType, decrFileInfo.FileName, decrFileInfo.LastWriteTimeUtc, encrFileInfo.RelativePath, encrFileInfo.LastWriteTimeUtc);

            return(entry);
        }
예제 #11
0
        public SyncLogEntry CreateNewLogEntryFromEncrPath(string encrFileName)
        {
            string encrFilePath = Path.Combine(EncrDirectory.FullName, encrFileName);

            FSEntry encrEntry = EncrDirectory.TryGetEntry(encrFileName);

            FileEntry header       = HelixFile.DecryptHeader(encrFilePath, DerivedBytesProvider);
            var       decrFileName = header.FileName;

            if (encrFileName != FileNameEncoder.EncodeName(decrFileName))
            {
                throw new HelixException("Encrypted file name does not match"); //todo: prompt for action
            }
            return(new SyncLogEntry(header.EntryType, header.FileName, header.LastWriteTimeUtc, encrEntry.RelativePath, encrEntry.LastWriteTimeUtc));
        }
        public int AddUser(string username)
        {
            if (usersById.Count(u => u.Value.userName == username) != 0)
            {
                throw new Exception("User: "******" already exists!");
            }

            // create a new user with default home directory and shell
            // initially empty password
            User user = new User();

            user.userID            = nextUserID++;
            user.userName          = username;
            user.password          = null;
            user.shell             = "pshell";
            user.homeDirectory     = "/home/" + username;
            usersById[user.userID] = user;

            // create user's home directory if needed
            if (filesystem != null)
            {
                Directory root  = filesystem.GetRootDirectory();
                FSEntry   entry = filesystem.Find(user.homeDirectory);
                if (entry == null)
                {
                    Directory home;
                    entry = filesystem.Find("/home");
                    if (entry == null)
                    {
                        home = root.CreateDirectory("home");
                    }
                    else
                    {
                        home = entry as Directory;
                    }
                    home.CreateDirectory(user.userName);
                }
            }

            // save the user to the password file
            SavePasswordFile();

            // return user id
            return(user.userID);
        }
예제 #13
0
파일: Program.cs 프로젝트: Cratez/SimpleFS
        static void TestfileSystem()
        {
            try
            {
                Random   r    = new Random();
                SlowDisk disk = new SlowDisk(1);
                disk.TurnOn();

                FileSystem fs = new SimpleFS();
                fs.Format(disk);
                fs.Mount(disk, "/");

                Directory root = fs.GetRootDirectory();
                root.CreateDirectory("Testing123");

                Directory dir = root.CreateDirectory("nested");

                File file = dir.CreateFile("nestedfile");

                FileStream filestream = file.Open();
                filestream.Write(0, CreateTestBytes(r, 142));
                filestream.Close();

                root.CreateFile("rootfile");

                fs.Find("/rootfile");
                FSEntry f        = fs.Find("/nested/nestedfile");
                string  fullname = f.FullPathName;

                RescursivelyPrintDirectories(root);

                fs.Unmount("/");
                disk.TurnOff();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Test File System failed. Ex: " + ex.Message);
            }
        }
        private void SavePasswordFile()
        {
            // Save all users to the password file

            // format the data as such
            // userID;username;password;homedir;shell
            string data = "";

            foreach (User u in usersById.Values)
            {
                data += u.userID.ToString() + ";";
                data += u.userName + ";";
                data += u.password + ";";
                data += u.homeDirectory + ";";
                data += u.shell + "\n";
            }


            // Write to file
            Directory root = filesystem.GetRootDirectory();
            File      pwfile;
            FSEntry   entry = filesystem.Find("/" + passwordFileName);

            if (entry == null)
            {
                pwfile = root.CreateFile(passwordFileName);
            }
            else
            {
                pwfile = entry as File;
            }
            FileStream stream = pwfile.Open();

            stream.Write(0, ASCIIEncoding.ASCII.GetBytes(data));
            stream.Close();
        }
예제 #15
0
        public void Navigate(string path)
        {
            if (Directory.Exists(path))
            {
                _currentDirectory = path;
                CurrentPath       = path;

                _entries.Clear();

                foreach (var file in Directory.GetFileSystemEntries(path))
                {
                    FSEntry fsEntry = new FSEntry(file);

                    if (fsEntry.Attributes.HasFlag(FileAttributes.Hidden) == false &&
                        fsEntry.Attributes.HasFlag(FileAttributes.System) == false &&
                        fsEntry.IsDirectory)
                    {
                        _entries.Add(fsEntry);
                    }
                }

                RefreshList();
            }
        }
예제 #16
0
파일: measurers.cs 프로젝트: kig/filezoo
 /** FAST */
 public double Measure(FSEntry d)
 {
     return Math.Max(1.0, d.SubTreeSize);
 }
예제 #17
0
파일: measurers.cs 프로젝트: kig/filezoo
 /** UNIMPORTANT */
 public double Measure(FSEntry d)
 {
     return 1.0;
 }
예제 #18
0
파일: measurers.cs 프로젝트: kig/filezoo
 /** FAST */
 public double Measure(FSEntry d)
 {
     bool isDotFile = d.Name[0] == '.';
     if (isDotFile) return 0.05;
     return (d.IsDirectory ? 10.0 : 1.0);
 }
예제 #19
0
파일: filezoo.cs 프로젝트: kig/filezoo
 void ToggleSpan(FSEntry start, FSEntry end)
 {
     if (start.ParentDir == end.ParentDir) {
       FSEntry[] entries = end.ParentDir.Entries.ToArray ();
       int startIdx = Array.IndexOf(entries, start);
       int endIdx = Array.IndexOf(entries, end);
       if (startIdx > -1 && endIdx > -1) {
     int i = Math.Min (startIdx, endIdx);
     int j = Math.Max (startIdx, endIdx);
     for (;i<=j;i++) {
       if (i != startIdx)
         ToggleSelection(entries[i].FullName);
     }
       }
       NeedRedraw = true;
     }
 }
예제 #20
0
        public List <FSEntry> ScanAndCompressDir(string dir, List <FixupPair> dirOffsetsToFixup, bool recomp)
        {
            string[]       entries         = Directory.GetFileSystemEntries(dir);
            string         lowerDecompDir  = VolFile.DecompDir.ToLower();
            List <FSEntry> curDirEntries   = new List <FSEntry>();
            List <FSEntry> subDirEntries   = new List <FSEntry>();
            FSEntry        startOfDirEntry = new FSEntry();

            startOfDirEntry.tocEntry             = new TocEntry();
            startOfDirEntry.tocEntry.dateTime    = (int)(DateTime.Now - dtEpoch).TotalSeconds;
            startOfDirEntry.tocEntry.flags       = TOCFlags_Directory;
            startOfDirEntry.tocEntry.offsetIndex = 0;
            startOfDirEntry.compressedFile       = null;
            startOfDirEntry.name = "..";
            startOfDirEntry.size = 0;
            curDirEntries.Add(startOfDirEntry);
            foreach (string e in entries)
            {
                string  justFileName  = Path.GetFileName(e);
                string  lowerFileName = justFileName.ToLower();
                FSEntry fe            = new FSEntry();
                fe.name                 = justFileName;
                fe.tocEntry             = new TocEntry();
                fe.tocEntry.flags       = TOCFlags_File;
                fe.tocEntry.offsetIndex = 0;
                fe.tocEntry.name        = new byte[25];
                if (!Directory.Exists(e))
                {
                    Debug.Assert(File.Exists(e));
                    fe.size              = 0;
                    fe.diskFile          = e;
                    fe.tocEntry.dateTime = GetFileCreationTimeInSeconds(e);
                }
                else if (lowerFileName != lowerDecompDir)
                {
                    fe.tocEntry.dateTime = GetDirectoryCreationTimeInSeconds(e);
                    fe.tocEntry.flags    = TOCFlags_Directory;
                    fe.diskFile          = null;
                    FixupPair dirFixup = new FixupPair(fe, null);
                    dirOffsetsToFixup.Add(dirFixup);
                    List <FSEntry> childContents = ScanAndCompressDir(e, dirOffsetsToFixup, recomp);
                    dirFixup.Value = childContents[0];
                    dirOffsetsToFixup.Add(new FixupPair(childContents[0], curDirEntries[0]));
                    subDirEntries.AddRange(childContents);
                }
                else
                {
                    continue;  // we don't want an entry for the decomp dir
                }
                curDirEntries.Add(fe);
            }
            curDirEntries.Sort();
            string decompDir = Path.Combine(dir, VolFile.DecompDir);

            if (recomp && Directory.Exists(decompDir))
            {
                bool           added = false;
                List <FSEntry> recompressedEntries = RecompressDir(decompDir);
                foreach (FSEntry r in recompressedEntries)
                {
                    int where = curDirEntries.BinarySearch(r);
                    if (where > 0)
                    {
                        curDirEntries[where] = r;
                    }
                    else
                    {
                        added = true;
                        curDirEntries.Add(r);
                    }
                }
                if (added)
                {
                    curDirEntries.Sort();
                }
            }
            // last file in the dir has this set
            // there aren't any empty directories in the real vol, so I don't know what will
            // happen if you include one. Setting the LastEntry flag on the .. entry might
            // make it work, or it might break it, I've no idea. But I've attempted to support
            // it anyway
            curDirEntries[curDirEntries.Count - 1].tocEntry.flags |= TOCFlags_LastEntry;
            curDirEntries.AddRange(subDirEntries);
            return(curDirEntries);
        }
예제 #21
0
파일: filezoo.cs 프로젝트: kig/filezoo
    /** BLOCKING - startup dir latency */
    public Filezoo(string dirname)
    {
        Selection = new Dictionary<string, bool> ();
        Renderer = new FSDraw ();

        clipboard = Clipboard.Get(Gdk.Atom.Intern("CLIPBOARD", true));

        SortField = SortFields[0];
        SizeField = SizeFields[0];
        Zoomer = new FlatZoomer ();

        Gdk.Colormap cm = Screen.RgbaColormap;
        if (cm != null && Screen.IsComposited) {
          Widget.DefaultColormap = cm;
          Colormap = cm;
          UseRgbaVisuals = true;
        }

        SetCurrentDir (dirname);

        Helpers.StartupProfiler.Time ("SetCurrentDir");

        CanFocus = true;
        KeyPressEvent += delegate (object o, KeyPressEventArgs args) {
          Cancelled = true;
          Gdk.ModifierType state = args.Event.State;
          switch (args.Event.Key) {
        case Gdk.Key.Control_L:
        case Gdk.Key.Control_R:
          state |= Gdk.ModifierType.ControlMask;
          break;
        case Gdk.Key.Shift_L:
        case Gdk.Key.Shift_R:
          state |= Gdk.ModifierType.ShiftMask;
          break;
        case Gdk.Key.Alt_L:
        case Gdk.Key.Alt_R:
          state |= Gdk.ModifierType.Mod1Mask;
          break;
          }
          SetCursor (state);
        };

        KeyReleaseEvent += delegate (object o, KeyReleaseEventArgs args) {
          Cancelled = true;
          if (args.Event.Key == Gdk.Key.Escape && Selection.Count > 0) {
        ClearSelection ();
        args.RetVal = true;
          } else if ((args.Event.State & Gdk.ModifierType.ControlMask) == Gdk.ModifierType.ControlMask) {
        switch (args.Event.Key) {
          case Gdk.Key.x:
            CutSelection(CurrentDirPath);
            break;
          case Gdk.Key.c:
            CopySelection(CurrentDirPath);
            break;
          case Gdk.Key.v:
            PasteSelection(CurrentDirPath);
            break;
        }
          } else {
        switch (args.Event.Key) {
          case Gdk.Key.Delete:
            TrashSelection ();
            break;
          case Gdk.Key.BackSpace:
            GoToParent ();
            break;
          case Gdk.Key.Home:
            SetCurrentDir (Helpers.HomeDir);
            break;
        }
          }
          Gdk.ModifierType state = args.Event.State;
          switch (args.Event.Key) {
        case Gdk.Key.Control_L:
        case Gdk.Key.Control_R:
          state &= ~Gdk.ModifierType.ControlMask;
          break;
        case Gdk.Key.Shift_L:
        case Gdk.Key.Shift_R:
          state &= ~Gdk.ModifierType.ShiftMask;
          break;
        case Gdk.Key.Alt_L:
        case Gdk.Key.Alt_R:
          state &= ~Gdk.ModifierType.Mod1Mask;
          break;
          }
          SetCursor (state);
        };

        DragDataGet += delegate (object o, DragDataGetArgs args) {
          string items = "file://" + DragSourcePath;
          if (Selection.Count > 0 && Selection.ContainsKey(DragSourcePath))
        items = GetSelectionData ();
          args.SelectionData.Set(args.SelectionData.Target, 8, System.Text.Encoding.UTF8.GetBytes(items));
          args.SelectionData.Text = items;
        };

        DragEnd += delegate {
          GetSelectionData ();
          Cancelled = true;
          dragInProgress = false;
          DragSourceEntry = null;
          DragSourcePath = null;
        };

        /** DESCTRUCTIVE */
        DragDataReceived += delegate (object sender, DragDataReceivedArgs e) {
          Cancelled = true;
          string targetPath = FindHit (Width, Height, e.X, e.Y, 8).Target.FullName;
          HandleSelectionData (e.SelectionData, e.Context.SuggestedAction, targetPath);
        };

        Gtk.Drag.DestSet (this, DestDefaults.All, target_table,
        Gdk.DragAction.Move
          | Gdk.DragAction.Copy
          | Gdk.DragAction.Ask
        );

        AddEvents((int)(
        Gdk.EventMask.ButtonPressMask
          | Gdk.EventMask.ButtonReleaseMask
          | Gdk.EventMask.ScrollMask
          | Gdk.EventMask.PointerMotionMask
          | Gdk.EventMask.EnterNotifyMask
          | Gdk.EventMask.KeyPressMask
          | Gdk.EventMask.KeyReleaseMask
          | Gdk.EventMask.LeaveNotifyMask
        ));

        ThreadStart ts = new ThreadStart (PreDrawCallback);
        Thread t = new Thread(ts);
        t.IsBackground = true;
        t.Start ();

        System.Timers.Timer t1 = new System.Timers.Timer(50);
        t1.Elapsed += new ElapsedEventHandler (CheckUpdates);
        System.Timers.Timer t2 = new System.Timers.Timer(1000);
        t2.Elapsed += new ElapsedEventHandler (LongMonitor);
        t1.Enabled = true;
        t2.Enabled = true;
        GLib.Timeout.Add (10, new GLib.TimeoutHandler(CheckRedraw));
        Helpers.StartupProfiler.Total ("Pre-drawing startup");
    }
예제 #22
0
        public void Run(Terminal terminal)
        {
            // NOTE: takes over the current thread, returns only when shell exits
            // expects terminal to already be connected

            terminal.Echo = true;

            while (true)
            {
                //print command prompt
                terminal.Write($"{pwd.Name}> ");

                //get command line
                string cmdline = terminal.ReadLine();
                if (cmdline.Length == 0)
                {
                    continue;
                }


                // identify command
                string[] parts = cmdline.Split(' ');
                if (parts != null && parts.Length > 0)
                {
                    string cmd = parts[0];
                    if (cmd == "exit")
                    {
                        terminal.WriteLine("Bye!");
                        break;
                    }
                    else if (cmd == "pwd")
                    {
                        terminal.WriteLine(pwd.FullPathName);
                    }
                    else if (cmd == "ls")
                    {
                        foreach (FSEntry entry in pwd.GetSubDirectories())
                        {
                            terminal.WriteLine(entry.Name);
                        }
                        foreach (FSEntry entry in pwd.GetFiles())
                        {
                            terminal.WriteLine(entry.Name);
                        }
                    }
                    else if (cmd == "cd")
                    {
                        if (parts.Length == 2)
                        {
                            string dest = parts[1];
                            if (!dest.StartsWith("/"))
                            {
                                dest = pwd.FullPathName + "/" + dest;
                            }

                            FSEntry found = session.FileSystem.Find(dest);
                            if (found != null)
                            {
                                if (found.IsDirectory)
                                {
                                    pwd = (Directory)found;
                                }
                                else
                                {
                                    terminal.WriteLine("Error: " + dest + " is not a directory!");
                                }
                            }
                        }
                        else
                        {
                            terminal.WriteLine("Usage: cd <name>");
                        }
                    }
                    else if (cmd == "mkdir")
                    {
                        if (parts.Length == 2)
                        {
                            //validate commandline args...

                            //make dir
                            pwd.CreateDirectory(parts[1]);
                        }
                    }
                    else
                    {
                        terminal.WriteLine("Command not found!");
                    }
                }
                //run command
            }
        }
예제 #23
0
파일: filezoo.cs 프로젝트: kig/filezoo
    public void SetCurrentDir(string dirname, bool resetZoom)
    {
        Profiler p = new Profiler ();
        dirLatencyProfiler.Restart ();
        FirstFrameOfDir = true;

        if (dirname != Helpers.RootDir) dirname = dirname.TrimEnd(Helpers.DirSepC);
        UnixDirectoryInfo d = new UnixDirectoryInfo (dirname);
        string odp = CurrentDirPath;
        CurrentDirPath = d.FullName;

        if (odp != CurrentDirPath) {
          if (CurrentDirEntry != null && CurrentDirEntry.InProgress)
        FSCache.CancelTraversal ();
          CurrentDirEntry = FSCache.FastGet (CurrentDirPath);
          FSCache.Watch (CurrentDirPath);
        }

        FSNeedRedraw = true;
        if (resetZoom) ResetZoom ();
        UpdateLayout ();
        p.Time("SetCurrentDir");
    }
예제 #24
0
파일: filezoo.cs 프로젝트: kig/filezoo
 /** FAST */
 protected override bool OnButtonPressEvent(Gdk.EventButton e)
 {
     Profiler p = new Profiler ("OnButtonPressEvent", 10);
     GrabFocus ();
     SetCursor (e.State);
     p.Time ("SetCursor");
     dragStartX = dragX = e.X;
     dragStartY = dragY = e.Y;
     ZoomVelocity = 1;
     ThrowFrames.Clear ();
     ClickCancelled = Cancelled = false;
     if (ThrowVelocity != 0)
       ClickCancelled = true;
     ThrowVelocity = 0;
     if (e.Button == 1 || e.Button == 2)
       ThrowFrames.Add (new ThrowFrame(e.X, e.Y));
     dragging = false;
     if (e.Button == 3) {
       int w, h;
       e.Window.GetSize (out w, out h);
       ContextClick ((uint)w, (uint)h, e.X, e.Y);
     } else if (e.Button == 1 && !dragging) {
       DoubleClick = (e.Type == Gdk.EventType.TwoButtonPress);
     }
     if (e.Button == 1) {
       int w, h;
       e.Window.GetSize (out w, out h);
       DragSourceEntry = FindHit((uint)w, (uint)h, e.X, e.Y, 8).Target;
       DragSourcePath = DragSourceEntry.FullName;
     }
     p.Time ("Handled");
     return true;
 }
예제 #25
0
파일: filezoo.cs 프로젝트: kig/filezoo
 /** BLOCKING */
 protected override bool OnButtonReleaseEvent(Gdk.EventButton e)
 {
     Profiler p = new Profiler ("OnButtonReleaseEvent", 10);
     GrabFocus ();
     SetCursor (e.State);
     p.Time ("SetCursor");
     ZoomVelocity = 1;
     if (Cancelled) {
       Cancelled = DoubleClick = false;
     } else {
       if (e.Button == 1 && !dragging && !ClickCancelled) {
       InteractionProfiler.Start ();
     int w, h;
     e.Window.GetSize (out w, out h);
     AltKeyDown = (e.State & Gdk.ModifierType.Mod1Mask) == Gdk.ModifierType.Mod1Mask;
     CtrlKeyDown = (e.State & Gdk.ModifierType.ControlMask) == Gdk.ModifierType.ControlMask;
     ShiftKeyDown = (e.State & Gdk.ModifierType.ShiftMask) == Gdk.ModifierType.ShiftMask;
     if (AltKeyDown)
       ClearSelection ();
     using (Context scr = new Context (CachedSurface)) {
       scr.IdentityMatrix ();
       Click (scr, (uint)w, (uint)h, e.X, e.Y);
     }
     DoubleClick = false;
       }
       if (e.Button == 1 && ThrowFrames.Count > 0) {
     ThrowVelocity = 0;
     if (DateTime.Now.Subtract(LastMotionTime).TotalMilliseconds < 100) {
       ThrowFrames.Add (new ThrowFrame(e.X, e.Y));
       int len = Math.Min(10, ThrowFrames.Count-1);
       double vy = 0;
       for (int i=ThrowFrames.Count-len; i<ThrowFrames.Count; i++) {
         vy += ThrowFrames[i].Y - ThrowFrames[i-1].Y;
       }
       vy /= len;
       // Helpers.LogDebug("ThrowFrames.Count: {0}, vy: {1}", ThrowFrames.Count, vy);
       if (Math.Abs(vy) > 5) {
         ThrowVelocity = vy*2;
         NeedRedraw = true;
       }
     }
     ThrowFrames.Clear ();
       }
     }
     if (e.Button == 1) {
       if (!dragInProgress) {
     DragSourceEntry = null;
     DragSourcePath = null;
       }
       dragInProgress = false;
     }
     if (e.Button == 2) { ControlLineVisible = false; NeedRedraw = true; }
     dragging = false;
     panning = panning && dragInProgress;
     p.Time ("Handled");
     return true;
 }
예제 #26
0
파일: filezoo.cs 프로젝트: kig/filezoo
 /** BLOCKING */
 void ClickCurrentDir(Context cr, uint width, uint height, double x, double y)
 {
     Rectangle box = Transform (cr, width, height);
     if (x < box.X || x > box.X+box.Width || y < box.Y || y > box.Y+box.Height)
       return;
     cr.Scale (1, Zoomer.Z);
     cr.Translate (0.0, Zoomer.Y);
     List<ClickHit> hits = Renderer.Click (CurrentDirEntry, Prefixes, cr, box, x, y);
     foreach (ClickHit c in hits) {
       if (c.Height < 15.9) {
     if (c.Target.ParentDir == CurrentDirEntry) {
       double nz = (c.Target.IsDirectory ? 24 : 18) / c.Height;
       // Helpers.LogDebug("ZoomIn {0}x", nz);
       cr.Save ();
         cr.IdentityMatrix ();
         ZoomBy(cr, width, height, x, y, nz);
       cr.Restore ();
       break;
     }
       } else if (DoubleClick) {
     break;
       } else {
     if (AltKeyDown) {
       ClearSelection ();
     } else if (CtrlKeyDown) {
       ToggleSelection(c.Target.FullName);
       spanStart = c.Target;
       spanEnd = null;
     } else if (ShiftKeyDown) {
       if (spanStart != null) {
         if (spanEnd != null) {
           ToggleSpan(spanStart, spanEnd);
         }
         spanEnd = c.Target;
         ToggleSpan(spanStart, spanEnd);
       } else {
         ToggleSelection(c.Target.FullName);
         spanStart = c.Target;
         spanEnd = null;
       }
     } else {
       if (c.Target.IsDirectory) {
         // Helpers.LogDebug("Navigate {0}", c.Target.FullName);
         SetCurrentDir (c.Target.FullName);
       } else {
         // Helpers.LogDebug("Open {0}", c.Target.FullName);
         OpenFile(c.Target.FullName);
       }
     }
     UpdateLayout ();
     break;
       }
     }
 }
예제 #27
0
파일: fsentry.cs 프로젝트: kig/filezoo
 public DrawEntry(FSEntry f)
 {
     Height = f.Height;
     F = f;
 }
예제 #28
0
파일: measurers.cs 프로젝트: kig/filezoo
 /** FAST */
 public double Measure(FSEntry d)
 {
     double mul = (d.Name[0] == '.') ? 1.0 : 40.0;
     return (d.IsDirectory ? Math.Max(1, d.SubTreeCount) : 1.0) * mul;
 }
예제 #29
0
 public FixupPair(FSEntry inKey, FSEntry inValue)
 {
     pairKey   = inKey;
     pairValue = inValue;
 }
예제 #30
0
파일: measurers.cs 프로젝트: kig/filezoo
 /** FAST */
 public double Measure(FSEntry d)
 {
     long elapsed = (DateTime.Today.AddDays(1) - d.LastModified).Ticks;
     double mul = (d.Name[0] == '.') ? 1.0 : 20.0;
     return mul * (1 / Math.Max(1.0, (double)elapsed / (10000.0 * 300.0)));
 }
예제 #31
0
        public SyncResults TrySync(PreSyncDetails entry, ConsoleEx console = null)
        {
            const int encrTimespanPrecisionMS = 1000;

            //todo: ensure the entry direction and operation end up being the same
            //todo: ensure all the calling methods do something with the results

            //if (WhatIf)
            //    throw new InvalidOperationException("Unable to perform sync when WhatIf mode is set to true");
            if (entry == null)
            {
                throw new ArgumentNullException(nameof(entry));
            }

            if (entry.SyncMode == PreSyncMode.DecryptedSide)
            {
                SyncLogEntry logEntry = entry.LogEntry;


                string             encrPath = Path.Combine(EncrDirectory.FullName, HelixUtil.PathNative(entry.EncrFileName));
                string             decrPath = Path.Combine(DecrDirectory.FullName, HelixUtil.PathNative(entry.DecrFileName));
                FileEncryptOptions options  = new FileEncryptOptions();
                FileEntry          header   = null;
                options.BeforeWriteHeader = (h) => header = h;
                options.StoredFileName    = entry.DecrFileName;
                options.FileVersion       = Header.FileVersion;
                options.Log = (s) => console?.WriteLine(VerbosityLevel.Diagnostic, 1, s);

                if (WhatIf)
                {
                    EncrDirectory.WhatIfReplaceFile(encrPath, entry.DisplayFileLength);
                    if (entry.DecrInfo == null)
                    {
                        header = new FileEntry()
                        {
                            EntryType = FileEntryType.Removed,
                            FileName  = entry.DecrFileName,
                        };
                    }
                    else
                    {
                        header = entry.DecrInfo.ToFileEntry();
                    }
                }
                else
                {
                    HelixFile.Encrypt(decrPath, encrPath, DerivedBytesProvider, options);


                    //forces a change if the file was modified to quickly
                    if (logEntry != null && (File.GetLastWriteTimeUtc(encrPath) - logEntry.EncrModified).TotalMilliseconds < encrTimespanPrecisionMS)
                    {
                        File.SetLastWriteTimeUtc(encrPath, logEntry.EncrModified + TimeSpan.FromMilliseconds(encrTimespanPrecisionMS));
                    }

                    EncrDirectory.RefreshEntry(encrPath);
                }
                var newLogEntry = CreateEntryFromHeader(header, EncrDirectory.TryGetEntry(entry.EncrFileName));
                SyncLog.Add(newLogEntry);


                return(SyncResults.Success());
            }
            else if (entry.SyncMode == PreSyncMode.EncryptedSide)
            {
                if (entry.DisplayOperation == PreSyncOperation.Purge)
                {
                    SyncLog.Add(entry.GetUpdatedLogEntry());
                    return(SyncResults.Success());
                }
                else
                {
                    //todo: use the DisplayOperation to determine what to do (ensures the counts stay consistant)

                    SyncLogEntry logEntry        = entry.LogEntry;
                    SyncLogEntry fileSystemEntry = CreateNewLogEntryFromEncrPath(entry.EncrFileName);
                    if (logEntry?.ToString() == fileSystemEntry?.ToString())
                    {
                        return(SyncResults.Success()); //Unchanged
                    }
                    //todo: test to see if there are illegal characters
                    //todo: check if the name matches

                    string encrPath = HelixUtil.JoinNative(EncrDirectory.FullName, fileSystemEntry.EncrFileName);
                    string decrPath = HelixUtil.JoinNative(DecrDirectory.FullName, fileSystemEntry.DecrFileName);

                    //todo: if file exists with different case - skip file
                    var     exactPath = HelixUtil.GetExactPathName(decrPath);
                    FSEntry decrEntry = DecrDirectory.TryGetEntry(fileSystemEntry.DecrFileName);

                    if (decrEntry != null && decrEntry.RelativePath != fileSystemEntry.DecrFileName)
                    {
                        //todo: throw more specific exception
                        return(SyncResults.Failure(new HelixException($"Case only conflict file \"{decrPath}\" exists as \"{exactPath}\".")));
                    }

                    if (WhatIf)
                    {
                        if (entry.EncrHeader.EntryType == FileEntryType.File)
                        {
                            DecrDirectory.WhatIfReplaceFile(decrPath, entry.EncrHeader.Length, entry.EncrHeader.LastWriteTimeUtc);
                        }
                        else if (entry.EncrHeader.EntryType == FileEntryType.Removed)
                        {
                            DecrDirectory.WhatIfDeleteFile(decrPath);
                        }
                        else if (entry.EncrHeader.EntryType == FileEntryType.Directory)
                        {
                            DecrDirectory.WhatIfAddDirectory(decrPath);
                        }
                        else
                        {
                            throw new NotSupportedException();
                        }
                    }
                    else
                    {
                        HelixFile.Decrypt(encrPath, decrPath, DerivedBytesProvider);
                        //todo: get the date on the file system (needed if the filesystem has less precision
                        DecrDirectory.RefreshEntry(decrPath);
                    }

                    SyncLog.Add(fileSystemEntry);

                    return(SyncResults.Success());
                }
            }
            else if (entry.SyncMode == PreSyncMode.Match)
            {
                //Add to Log file (changed to be equal on both sides)
                SyncLogEntry fileSystemEntry = CreateNewLogEntryFromDecrPath(entry.DecrFileName);
                SyncLog.Add(fileSystemEntry);
                return(SyncResults.Success());
            }
            else if (entry.SyncMode == PreSyncMode.Unchanged)
            {
                //do nothing
                return(SyncResults.Success());
            }

            return(SyncResults.Failure(new HelixException($"Invalid sync mode {entry.SyncMode}")));
        }