public VisualGitRevisionType Resolve(GitOrigin origin, VisualGitRevisionType revision)
 {
     return Resolve(origin, revision.CurrentValue);
 }
Beispiel #2
0
        void SetRevision(VisualGitRevisionType rev)
        {
            if (rev == null && _currentRevType == null)
                return;
            else if (rev != null && _currentRevType != null && rev.Equals(_currentRevType))
                return;

            if (_revTypes == null)
                _revTypes = new List<VisualGitRevisionType>();

            if (_currentRevType != null && !_revTypes.Contains(_currentRevType))
                _revTypes.Add(_currentRevType);

            if (rev != null && !_revTypes.Contains(rev))
                _revTypes.Add(rev);

            _currentRevType = rev;

            EnsureList();

            foreach (Control c in versionTypePanel.Controls)
            {
                c.Enabled = c.Visible = false;
            }

            if (rev.HasUI)
            {
                if (rev.CurrentControl == null)
                    rev.InstantiateUIIn(versionTypePanel, EventArgs.Empty);

                rev.CurrentControl.Visible = rev.CurrentControl.Enabled = true;
            }

            typeCombo.SelectedItem = _currentRevType;
        }
        public VisualGitRevisionType Resolve(GitOrigin origin, VisualGitRevisionType revision)
        {
            if (revision == null)
                throw new ArgumentNullException("revision");

            foreach (IVisualGitRevisionProvider p in _providers)
            {
                VisualGitRevisionType r = p.Resolve(origin, revision);

                if (r != null)
                    return r;
            }

            return Resolve(origin, revision.CurrentValue);
        }
Beispiel #4
0
        private void EnsureList()
        {
            if (RevisionResolver == null || GitOrigin == null)
                return;

            foreach (VisualGitRevisionType ri in new ArrayList(typeCombo.Items))
            {
                if (!ri.IsValidOn(GitOrigin))
                {
                    if (ri == _currentRevType)
                    {
                        _newValue = ri.CurrentValue;
                        _currentRevType = null;
                    }
                    typeCombo.Items.Remove(ri);
                }
            }

            if (_revTypes != null)
                foreach (VisualGitRevisionType rt in _revTypes)
                {
                    if (rt.IsValidOn(GitOrigin) && !typeCombo.Items.Contains(rt))
                        typeCombo.Items.Add(rt);
                }
            else
                _revTypes = new List<VisualGitRevisionType>();

            foreach (VisualGitRevisionType rt in RevisionResolver.GetRevisionTypes(GitOrigin))
            {
                if (_revTypes.Contains(rt))
                    continue;

                _revTypes.Add(rt);
                typeCombo.Items.Add(rt);
            }

            if (_currentRevType == null && _newValue != null && _newValue != GitRevision.None)
            {
                VisualGitRevisionType rt = RevisionResolver.Resolve(GitOrigin, _newValue);

                if (rt != null && !rt.IsValidOn(GitOrigin))
                {
                    _newValue = GitOrigin.Target.Revision;
                    if (_newValue == null || _newValue == GitRevision.None)
                        _newValue = GitRevision.Base;

                    rt = RevisionResolver.Resolve(GitOrigin, _newValue);
                }

                SetRevision(rt);
            }

            if (_currentRevType != typeCombo.SelectedItem)
                typeCombo.SelectedItem = _currentRevType;
        }