Exemple #1
0
        void BlameFile_MouseMove(object sender, MouseEventArgs e)
        {
            if (_blame == null)
            {
                return;
            }

            int line = BlameFile.GetLineFromVisualPosY(e.Y);

            if (line >= _blame.Lines.Count)
            {
                return;
            }

            GitBlameHeader blameHeader = _blame.FindHeaderForCommitGuid(_blame.Lines[line].CommitGuid);

            if (blameHeader != lastBlameHeader)
            {
                BlameCommitter.ClearHighlighting();
                BlameFile.ClearHighlighting();
                for (int i = 0; i < _blame.Lines.Count; i++)
                {
                    if (_blame.Lines[i].CommitGuid == blameHeader.CommitGuid)
                    {
                        BlameCommitter.HighlightLine(i, Color.FromArgb(225, 225, 225));
                        BlameFile.HighlightLine(i, Color.FromArgb(225, 225, 225));
                    }
                }
                BlameCommitter.Refresh();
                BlameFile.Refresh();
                lastBlameHeader = blameHeader;
            }
        }
        private void ProcessBlame(string filename, GitRevision revision, IReadOnlyList <ObjectId> children, Control controlToMask, int lineNumber, int scrollpos)
        {
            var avatarSize = BlameAuthor.Font.Height + 1;

            var(gutter, body, avatars) = BuildBlameContents(filename, avatarSize);

            BlameAuthor.SetGitBlameGutter(avatars);

            ThreadHelper.JoinableTaskFactory.RunAsync(
                () => BlameAuthor.ViewTextAsync("committer.txt", gutter));
            ThreadHelper.JoinableTaskFactory.RunAsync(
                () => BlameFile.ViewTextAsync(_fileName, body));

            if (lineNumber > 0)
            {
                BlameFile.GoToLine(lineNumber - 1);
            }
            else
            {
                BlameFile.VScrollPosition = scrollpos;
            }

            _clickedBlameLine = null;

            _blameId = revision.ObjectId;
            CommitInfo.SetRevisionWithChildren(revision, children);

            controlToMask?.UnMask();
        }
        void BlameCommitter_MouseMove(object sender, MouseEventArgs e)
        {
            if (!BlameFile.Focused)
            {
                BlameFile.Focus();
            }

            if (_blame == null)
            {
                return;
            }

            int line = BlameCommitter.GetLineFromVisualPosY(e.Y);

            if (line >= _blame.Lines.Count)
            {
                return;
            }

            GitBlameHeader blameHeader = _blame.FindHeaderForCommitGuid(_blame.Lines[line].CommitGuid);

            string tooltipText = blameHeader.ToString();

            int newTooltipX = splitContainer2.SplitterDistance + 60;
            int newTooltipY = e.Y + splitContainer1.SplitterDistance + 20;

            if (lastTooltip != tooltipText || Math.Abs(lastTooltipX - newTooltipX) > 5 || Math.Abs(lastTooltipY - newTooltipY) > 5)
            {
                lastTooltip  = tooltipText;
                lastTooltipX = newTooltipX;
                lastTooltipY = newTooltipY;
                blameTooltip.Show(tooltipText, this, newTooltipX, newTooltipY);
            }
        }
Exemple #4
0
        public void LoadBlame(string guid, string fileName, RevisionGrid revGrid)
        {
            var scrollpos = BlameFile.ScrollPos;

            var blameCommitter = new StringBuilder();
            var blameFile      = new StringBuilder();

            _revGrid = revGrid;

            _blame = GitCommandHelpers.Blame(fileName, guid);

            for (int i = 0; i < _blame.Lines.Count; i++)
            {
                GitBlameLine   blameLine   = _blame.Lines[i];
                GitBlameHeader blameHeader = _blame.FindHeaderForCommitGuid(blameLine.CommitGuid);
                if (i > 0 && _blame.Lines[i - 1].CommitGuid == blameLine.CommitGuid)
                {
                    blameCommitter.AppendLine(new string(' ', 200));
                }
                else
                {
                    blameCommitter.AppendLine((blameHeader.Author + " - " + blameHeader.AuthorTime.ToString() + " - " + blameHeader.FileName + new string(' ', 100)).Trim(new char[] { '\r', '\n' }));
                }
                blameFile.AppendLine(blameLine.LineText.Trim(new char[] { '\r', '\n' }));
            }

            BlameCommitter.ViewText("committer.txt", blameCommitter.ToString());
            BlameFile.ViewText(fileName, blameFile.ToString());
            BlameFile.ScrollPos = scrollpos;

            BlameFile_SelectedLineChanged(null, 0);
        }
Exemple #5
0
        private void ProcessBlame(GitRevision revision, IReadOnlyList <ObjectId> children, Control controlToMask, int lineNumber, int scrollpos)
        {
            var gutter = new StringBuilder(capacity: 4096);
            var body   = new StringBuilder(capacity: 4096);

            GitBlameCommit lastCommit = null;

            // NOTE EOL white-space supports highlight on mouse-over.
            // Highlighting is done via text background colour.
            // If it could be done with a solid rectangle around the text,
            // the extra spaces added here could be omitted.

            foreach (var line in _blame.Lines)
            {
                if (line.Commit == lastCommit)
                {
                    gutter.Append(' ', 200).AppendLine();
                }
                else
                {
                    gutter.Append(line.Commit.Author);
                    gutter.Append(" - ");
                    gutter.Append(line.Commit.AuthorTime.ToString(CultureInfo.CurrentUICulture));
                    gutter.Append(" - ");
                    gutter.Append(line.Commit.FileName);
                    gutter.Append(' ', 100).AppendLine();
                }

                body.AppendLine(line.Text);

                lastCommit = line.Commit;
            }

            ThreadHelper.JoinableTaskFactory.RunAsync(
                () => BlameCommitter.ViewTextAsync("committer.txt", gutter.ToString()));
            ThreadHelper.JoinableTaskFactory.RunAsync(
                () => BlameFile.ViewTextAsync(_fileName, body.ToString()));

            if (lineNumber > 0)
            {
                BlameFile.GoToLine(lineNumber - 1);
            }
            else
            {
                BlameFile.ScrollPos = scrollpos;
            }

            _clickedBlameLine = null;

            _blameId = revision.ObjectId;
            CommitInfo.SetRevisionWithChildren(revision, children);

            controlToMask?.UnMask();
        }
Exemple #6
0
        public BlameFilePanel(Repository repository, BlameFile blameFile)
        {
            Verify.Argument.IsNotNull(repository, nameof(repository));
            Verify.Argument.IsNotNull(blameFile, nameof(blameFile));

            _repository = repository;
            BlameFile   = blameFile;
            _lineHover  = new TrackingService(e => Invalidate(GetLineBounds(e.Index)));
            _selStart   = -1;
            _selEnd     = -1;
            _selOrigin  = -1;
        }
Exemple #7
0
        public BlameFilePanel(Repository repository, BlameFile blameFile)
        {
            Verify.Argument.IsNotNull(repository, "repository");
            Verify.Argument.IsNotNull(blameFile, "blameFile");

            _repository = repository;
            _blameFile = blameFile;
            _lineHover = new TrackingService(e => Invalidate(GetLineBounds(e.Index)));
            _selStart = -1;
            _selEnd = -1;
            _selOrigin = -1;
        }
        private void BlameFile_MouseMove(object sender, MouseEventArgs e)
        {
            if (_blame == null)
            {
                return;
            }

            int line = BlameFile.GetLineFromVisualPosY(e.Y);

            if (line >= _blame.Lines.Count)
            {
                return;
            }

            GitBlameHeader blameHeader = _blame.FindHeaderForCommitGuid(_blame.Lines[line].CommitGuid);

            if (blameHeader != _lastBlameHeader)
            {
                BlameCommitter.ClearHighlighting();
                BlameFile.ClearHighlighting();
                int startLine = -1;
                int prevLine  = -1;
                for (int i = 0; i < _blame.Lines.Count; i++)
                {
                    if (_blame.Lines[i].CommitGuid == blameHeader.CommitGuid)
                    {
                        if (prevLine != i - 1 && startLine != -1)
                        {
                            BlameCommitter.HighlightLines(startLine, prevLine, Color.FromArgb(225, 225, 225));
                            BlameFile.HighlightLines(startLine, prevLine, Color.FromArgb(225, 225, 225));
                            startLine = -1;
                        }

                        prevLine = i;
                        if (startLine == -1)
                        {
                            startLine = i;
                        }
                    }
                }

                if (startLine != -1)
                {
                    BlameCommitter.HighlightLines(startLine, prevLine, Color.FromArgb(225, 225, 225));
                    BlameFile.HighlightLines(startLine, prevLine, Color.FromArgb(225, 225, 225));
                }

                BlameCommitter.Refresh();
                BlameFile.Refresh();
                _lastBlameHeader = blameHeader;
            }
        }
        private void ProcessBlame(GitRevision revision, List <string> children, Control controlToMask, int line, int scrollpos)
        {
            var blameCommitter = new StringBuilder();
            var blameFile      = new StringBuilder();

            for (int i = 0; i < _blame.Lines.Count; i++)
            {
                GitBlameLine   blameLine   = _blame.Lines[i];
                GitBlameHeader blameHeader = _blame.FindHeaderForCommitGuid(blameLine.CommitGuid);
                if (i > 0 && _blame.Lines[i - 1].CommitGuid == blameLine.CommitGuid)
                {
                    blameCommitter.AppendLine(new string(' ', 200));
                }
                else
                {
                    blameCommitter.AppendLine(
                        (blameHeader.Author + " - " + blameHeader.AuthorTime + " - " + blameHeader.FileName +
                         new string(' ', 100)).Trim(new[] { '\r', '\n' }));
                }
                if (blameLine.LineText == null)
                {
                    blameFile.AppendLine("");
                }
                else
                {
                    blameFile.AppendLine(blameLine.LineText.Trim(new[] { '\r', '\n' }));
                }
            }

            BlameCommitter.ViewText("committer.txt", blameCommitter.ToString());
            BlameFile.ViewText(_fileName, blameFile.ToString());
            if (line > 0)
            {
                BlameFile.GoToLine(line - 1);
            }
            else
            {
                BlameFile.ScrollPos = scrollpos;
            }

            _clickedBlameLine = new GitBlameLine();

            _blameHash = revision.Guid;
            CommitInfo.SetRevisionWithChildren(revision, children);

            if (controlToMask != null)
            {
                controlToMask.UnMask();
            }
        }
        private void BlameFile_MouseMove(object sender, MouseEventArgs e)
        {
            if (_blame is null)
            {
                return;
            }

            var lineIndex = BlameFile.GetLineFromVisualPosY(e.Y);

            var blameCommit = lineIndex < _blame.Lines.Count
                ? _blame.Lines[lineIndex].Commit
                : null;

            HighlightLinesForCommit(blameCommit);
        }
        private void HighlightLinesForCommit([CanBeNull] GitBlameCommit commit)
        {
            if (commit == _highlightedCommit)
            {
                return;
            }

            _highlightedCommit = commit;

            BlameAuthor.ClearHighlighting();
            BlameFile.ClearHighlighting();

            if (commit is null)
            {
                return;
            }

            int startLine = -1;
            int prevLine  = -1;

            for (int i = 0; i < _blame.Lines.Count; i++)
            {
                if (ReferenceEquals(_blame.Lines[i].Commit, commit))
                {
                    if (prevLine != i - 1 && startLine != -1)
                    {
                        BlameAuthor.HighlightLines(startLine, prevLine, SystemColors.ControlLight);
                        BlameFile.HighlightLines(startLine, prevLine, SystemColors.ControlLight);
                        startLine = -1;
                    }

                    prevLine = i;
                    if (startLine == -1)
                    {
                        startLine = i;
                    }
                }
            }

            if (startLine != -1)
            {
                BlameAuthor.HighlightLines(startLine, prevLine, SystemColors.ControlLight);
                BlameFile.HighlightLines(startLine, prevLine, SystemColors.ControlLight);
            }

            BlameAuthor.Refresh();
            BlameFile.Refresh();
        }
Exemple #12
0
        void BlameFile_MouseMove(object sender, MouseEventArgs e)
        {
            if (_blame == null)
            {
                return;
            }

            int line = BlameFile.GetLineFromVisualPosY(e.Y);

            if (line >= _blame.Lines.Count)
            {
                return;
            }

            GitBlameHeader blameHeader = _blame.FindHeaderForCommitGuid(_blame.Lines[line].CommitGuid);

            string tooltipText = blameHeader.ToString();

            if (lastTooltip != tooltipText)
            {
                BlameCommitter.ClearHighlighting();
                BlameFile.ClearHighlighting();
                for (int i = 0; i < _blame.Lines.Count; i++)
                {
                    if (_blame.Lines[i].CommitGuid == blameHeader.CommitGuid)
                    {
                        BlameCommitter.HighlightLine(i, Color.FromArgb(225, 225, 225));
                        BlameFile.HighlightLine(i, Color.FromArgb(225, 225, 225));
                    }
                }
                BlameCommitter.Refresh();
                BlameFile.Refresh();
            }

            int newTooltipX = e.X + splitContainer2.SplitterDistance + 20;
            int newTooltipY = e.Y + splitContainer1.SplitterDistance + 20;

            if (lastTooltip != tooltipText || Math.Abs(lastTooltipX - newTooltipX) > 5 || Math.Abs(lastTooltipY - newTooltipY) > 5)
            {
                lastTooltip  = tooltipText;
                lastTooltipX = newTooltipX;
                lastTooltipY = newTooltipY;
                //blameTooltip.Show(tooltipText, this, newTooltipX, newTooltipY);
            }
        }
Exemple #13
0
        public void LoadBlame(string guid, string fileName, RevisionGrid revGrid)
        {
            var scrollpos = BlameFile.ScrollPos;

            var blameCommitter = new StringBuilder();
            var blameFile      = new StringBuilder();

            _revGrid = revGrid;

            _blame = Settings.Module.Blame(fileName, guid);

            for (int i = 0; i < _blame.Lines.Count; i++)
            {
                GitBlameLine   blameLine   = _blame.Lines[i];
                GitBlameHeader blameHeader = _blame.FindHeaderForCommitGuid(blameLine.CommitGuid);
                if (i > 0 && _blame.Lines[i - 1].CommitGuid == blameLine.CommitGuid)
                {
                    blameCommitter.AppendLine(new string(' ', 200));
                }
                else
                {
                    blameCommitter.AppendLine((blameHeader.Author + " - " + blameHeader.AuthorTime + " - " + blameHeader.FileName + new string(' ', 100)).Trim(new[] { '\r', '\n' }));
                }
                if (blameLine.LineText == null)
                {
                    blameFile.AppendLine("");
                }
                else
                {
                    blameFile.AppendLine(blameLine.LineText.Trim(new char[] { '\r', '\n' }));
                }
            }

            BlameCommitter.ViewText("committer.txt", blameCommitter.ToString());
            BlameFile.ViewText(fileName, blameFile.ToString());
            BlameFile.ScrollPos = scrollpos;

            commitInfo.SetRevision(guid);
        }
        private void BlameAuthor_MouseMove(object sender, MouseEventArgs e)
        {
            if (!BlameFile.Focused)
            {
                BlameFile.Focus();
            }

            if (_blame is null)
            {
                return;
            }

            _lineIndex = BlameAuthor.GetLineFromVisualPosY(e.Y);

            var blameCommit = _lineIndex < _blame.Lines.Count
                ? _blame.Lines[_lineIndex].Commit
                : null;

            HighlightLinesForCommit(blameCommit);

            if (blameCommit is null)
            {
                return;
            }

            int newTooltipX = splitContainer2.SplitterDistance + 60;
            int newTooltipY = e.Y + splitContainer1.SplitterDistance + 20;

            if (_tooltipCommit != blameCommit || Math.Abs(_lastTooltipX - newTooltipX) > 5 || Math.Abs(_lastTooltipY - newTooltipY) > 5)
            {
                _tooltipCommit = blameCommit;
                _lastTooltipX  = newTooltipX;
                _lastTooltipY  = newTooltipY;
                blameTooltip.Show(blameCommit.ToString(), this, newTooltipX, newTooltipY);
            }
        }
Exemple #15
0
        public void LoadBlame(GitRevision revision, List <string> children, string fileName, RevisionGrid revGrid, Control controlToMask, Encoding encoding)
        {
            string guid = revision.Guid;

            //refresh only when something changed
            if (guid.Equals(CommitInfo.Revision) && fileName.Equals(fileName) && revGrid == _revGrid && encoding == _encoding)
            {
                return;
            }

            if (controlToMask != null)
            {
                controlToMask.Mask();
            }

            var scrollpos = BlameFile.ScrollPos;

            var blameCommitter = new StringBuilder();
            var blameFile      = new StringBuilder();

            _revGrid  = revGrid;
            _fileName = fileName;
            _encoding = encoding;

            blameLoader.Load(() =>
            {
                _blame = Module.Blame(fileName, guid, encoding);
            },
                             () =>
            {
                for (int i = 0; i < _blame.Lines.Count; i++)
                {
                    GitBlameLine blameLine     = _blame.Lines[i];
                    GitBlameHeader blameHeader = _blame.FindHeaderForCommitGuid(blameLine.CommitGuid);
                    if (i > 0 && _blame.Lines[i - 1].CommitGuid == blameLine.CommitGuid)
                    {
                        blameCommitter.AppendLine(new string(' ', 200));
                    }
                    else
                    {
                        blameCommitter.AppendLine((blameHeader.Author + " - " + blameHeader.AuthorTime + " - " + blameHeader.FileName + new string(' ', 100)).Trim(new[] { '\r', '\n' }));
                    }
                    if (blameLine.LineText == null)
                    {
                        blameFile.AppendLine("");
                    }
                    else
                    {
                        blameFile.AppendLine(blameLine.LineText.Trim(new char[] { '\r', '\n' }));
                    }
                }

                BlameCommitter.ViewText("committer.txt", blameCommitter.ToString());
                BlameFile.ViewText(fileName, blameFile.ToString());
                BlameFile.ScrollPos = scrollpos;

                CommitInfo.SetRevisionWithChildren(revision, children);

                if (controlToMask != null)
                {
                    controlToMask.UnMask();
                }
            });
        }