Exemple #1
0
        private void OnTreeViewShowContextMenu(object sender, MouseEventArgs e)
        {
            if (Context == null)
            {
                return;
            }

            Point screen;

            if (e.X == -1 && e.Y == -1)
            {
                screen = treeView.GetSelectionPoint();
                if (screen.IsEmpty)
                {
                    return;
                }
            }
            else
            {
                screen = e.Location;
            }

            IAnkhCommandService cs = Context.GetService <IAnkhCommandService>();

            cs.ShowContextMenu(AnkhCommandMenu.RepositoryExplorerContextMenu, screen.X, screen.Y);
        }
Exemple #2
0
            void OnExited(object sender, EventArgs e)
            {
                Process             process = sender as Process;
                IAnkhCommandService cmd     = GetService <IAnkhCommandService>();

                if (cmd != null)
                {
                    cmd.PostIdleAction(Dispose);
                }
                else
                {
                    Dispose();
                }

                if (process != null && _resolvedExitCodes != null)
                {
                    foreach (int ec in _resolvedExitCodes)
                    {
                        if (ec == process.ExitCode)
                        {
                            cmd.PostIdleAction(MarkResolved);
                            break;
                        }
                    }
                }

                IFileStatusMonitor m = GetService <IFileStatusMonitor>();

                if (m != null)
                {
                    m.ScheduleSvnStatus(_toMonitor);
                }
            }
Exemple #3
0
        public override void OnShowContextMenu(MouseEventArgs e)
        {
            base.OnShowContextMenu(e);

            if (Context == null)
            {
                return;
            }

            Point screen;
            bool  isHeaderContextMenu = false;

            if (e.X == -1 && e.Y == -1)
            {
                if (SelectedItems.Count > 0)
                {
                    screen = PointToScreen(SelectedItems[SelectedItems.Count - 1].Position);
                }
                else
                {
                    screen = PointToScreen(new Point(1, 1));
                    isHeaderContextMenu = true;
                }
            }
            else
            {
                isHeaderContextMenu = PointToClient(e.Location).Y < HeaderHeight;
                screen = e.Location;
            }

            IAnkhCommandService cs = Context.GetService <IAnkhCommandService>();

            cs.ShowContextMenu(isHeaderContextMenu ? AnkhCommandMenu.ListViewHeader : AnkhCommandMenu.LogChangedPathsContextMenu, screen);
        }
        private void OnContextMenuOpening(object sender, ContextMenuEventArgs e)
        {
            e.Handled = true;
            UIElement el = e.OriginalSource as UIElement ?? PendingChangesList;

            Point    wp       = el.PointToScreen(new Point(e.CursorLeft, e.CursorTop));
            WinPoint p        = new WinPoint((int)wp.X, (int)wp.Y);
            bool     showSort = false;

            if (PendingChangesList.ContainerFromElement(el) == null)
            {
                showSort = true;
            }

            IAnkhCommandService mcs = Context.GetService <IAnkhCommandService>();

            if (mcs != null)
            {
                if (showSort)
                {
                    mcs.ShowContextMenu(AnkhCommandMenu.PendingCommitsHeaderContextMenu, p);
                }
                else
                {
                    mcs.ShowContextMenu(AnkhCommandMenu.PendingCommitsContextMenu, p);
                }
            }
        }
        private void ShowContextMenu()
        {
            Point p = MousePosition;

            if (_context != null)
            {
                IAnkhCommandService cs = _context.GetService <IAnkhCommandService>();
                cs.ShowContextMenu(AnkhCommandMenu.AnnotateContextMenu, p.X, p.Y);
            }
        }
Exemple #6
0
        private static void AutoOpenCommand(CommandEventArgs e, SvnOrigin origin)
        {
            IAnkhCommandService   svc = e.GetService <IAnkhCommandService>();
            IAnkhSolutionSettings solutionSettings = e.GetService <IAnkhSolutionSettings>();

            if (svc == null || solutionSettings == null)
            {
                return;
            }

            // Ok, we can assume we have a file
            string filename = origin.Target.FileName;
            string ext      = Path.GetExtension(filename);

            if (string.IsNullOrEmpty(ext))
            {
                // No extension -> Open as text
                svc.PostExecCommand(AnkhCommand.ViewInVsText);
                return;
            }

            foreach (string projectExt in solutionSettings.AllProjectExtensionsFilter.Split(';'))
            {
                if (projectExt.TrimStart('*').Trim().Equals(ext, StringComparison.OrdinalIgnoreCase))
                {
                    // We found a project or solution, use Open from Subversion to create a checkout

                    svc.PostExecCommand(AnkhCommand.FileFileOpenFromSubversion, origin);
                    return;
                }
            }

            bool odd = false;

            foreach (string block in solutionSettings.OpenFileFilter.Split('|'))
            {
                odd = !odd;
                if (odd)
                {
                    continue;
                }

                foreach (string itemExt in block.Split(';'))
                {
                    if (itemExt.TrimStart('*').Trim().Equals(ext, StringComparison.OrdinalIgnoreCase))
                    {
                        svc.PostExecCommand(AnkhCommand.ViewInVsNet);
                        return;
                    }
                }
            }

            // Ultimate fallback: Just ask the user what to do (don't trust the repository!)
            svc.PostExecCommand(AnkhCommand.ViewInWindowsWith);
        }
Exemple #7
0
        public void OnExecute(CommandEventArgs e)
        {
            if (_commandService == null)
                _commandService = e.GetService<IAnkhCommandService>();
            if (_projectNotifier == null)
                _projectNotifier = e.GetService<ProjectNotifier>(typeof(IFileStatusMonitor));

            _commandService.TockCommand(e.Command);

            _projectNotifier.HandleEvent(e.Command);
        }
        public void OnExecute(CommandEventArgs e)
        {
            if (_commandService == null)
                _commandService = e.GetService<IAnkhCommandService>();
            if (_pendingChanges == null)
                _pendingChanges = e.GetService<PendingChangeManager>(typeof(IPendingChangesManager));

            _commandService.TockCommand(e.Command);

            _pendingChanges.OnTickRefresh();
        }
        public void OnExecute(CommandEventArgs e)
        {
            if (_commandService == null)
            {
                _commandService = e.GetService <IAnkhCommandService>();
                _pendingChanges = e.GetService <PendingChangeManager>(typeof(IPendingChangesManager));
            }

            _commandService.TockCommand(e.Command);

            _pendingChanges.OnTickRefresh();
        }
Exemple #10
0
        protected override void OnMouseDoubleClick(MouseEventArgs e)
        {
            base.OnMouseDoubleClick(e);
            Point mp = PointToClient(MousePosition);
            ListViewHitTestInfo info = HitTest(mp);
            PathListViewItem    lvi  = info.Item as PathListViewItem;

            if (lvi != null && Context != null)
            {
                IAnkhCommandService cmdSvc = Context.GetService <IAnkhCommandService>();
                cmdSvc.PostExecCommand(AnkhCommand.LogShowChanges);
            }
        }
Exemple #11
0
        public void OnExecute(CommandEventArgs e)
        {
            if (_commandService == null)
                _commandService = e.GetService<IAnkhCommandService>();
            if (_projectTracker == null)
                _projectTracker = e.GetService<ProjectTracker>(typeof(IAnkhProjectDocumentTracker));
            if(_sccProvider == null)
                _sccProvider = e.GetService<AnkhSccProvider>(typeof(IAnkhSccService));

            _commandService.TockCommand(e.Command);

            _projectTracker.OnSccCleanup(e);
            _sccProvider.OnSccCleanup(e);
        }
Exemple #12
0
        void RegisterForSccCleanup()
        {
            if (_registeredSccCleanup)
            {
                return;
            }

            IAnkhCommandService cmd = CommandService;

            if (cmd != null)
            {
                cmd.PostTickCommand(ref _registeredSccCleanup, AnkhCommand.SccFinishTasks);
            }
        }
Exemple #13
0
        void ScheduleUpdateNotify()
        {
            if (_scheduled)
            {
                return;
            }

            IAnkhCommandService cs = _context.GetService <IAnkhCommandService>();

            if (cs != null)
            {
                cs.PostTickCommand(ref _scheduled, AnkhCommand.TickRefreshSvnItems);
            }
        }
Exemple #14
0
        public void OnExecute(CommandEventArgs e)
        {
            if (_commandService == null)
                _commandService = e.GetService<IAnkhCommandService>();
            if (_fileCache == null)
                _fileCache = e.GetService<FileStatusCache>(typeof(IFileStatusCache));

            _commandService.TockCommand(e.Command);

            if (e.Command == AnkhCommand.FileCacheFinishTasks)
                _fileCache.OnCleanup();
            else
                _fileCache.BroadcastChanges();
        }
Exemple #15
0
        public void OnExecute(CommandEventArgs e)
        {
            if (_commandService == null)
            {
                _commandService = e.GetService <IAnkhCommandService>();
            }
            if (_projectNotifier == null)
            {
                _projectNotifier = e.GetService <ProjectNotifier>(typeof(IFileStatusMonitor));
            }

            _commandService.TockCommand(e.Command);

            _projectNotifier.HandleEvent(e.Command);
        }
Exemple #16
0
        public void MaybeMigrate()
        {
            IAnkhPackage        pkg = GetService <IAnkhPackage>();
            IAnkhCommandService cs  = GetService <IAnkhCommandService>();

            if (pkg == null || cs == null)
            {
                return;
            }

            using (RegistryKey rkRoot = pkg.UserRegistryRoot)
                using (RegistryKey ankhMigration = rkRoot.CreateSubKey("AnkhSVN-Trigger"))
                {
                    int    migrateFrom = 0;
                    object value       = ankhMigration.GetValue(MigrateId, migrateFrom);

                    if (value is int)
                    {
                        migrateFrom = (int)value;
                    }
                    else
                    {
                        ankhMigration.DeleteValue(MigrateId, false);
                    }

                    if (migrateFrom < 0)
                    {
                        migrateFrom = 0;
                    }

                    if (migrateFrom >= AnkhId.MigrateVersion)
                    {
                        return;                 // Nothing to do
                    }
                    try
                    {
                        if (cs.DirectlyExecCommand(AnkhCommand.MigrateSettings).Success)
                        {
                            ankhMigration.SetValue(MigrateId, AnkhId.MigrateVersion);
                        }
                    }
                    catch
                    { /* NOP: Don't fail here... ever! */ }
                }
        }
        public override void OnShowContextMenu(MouseEventArgs e)
        {
            base.OnShowContextMenu(e);

            bool  isHeaderContext = false;
            Point screen;

            if (e.X == -1 && e.Y == -1)
            {
                // Handle keyboard context menu
                if (SelectedItems.Count > 0)
                {
                    screen = PointToScreen(SelectedItems[SelectedItems.Count - 1].Position);
                }
                else
                {
                    isHeaderContext = true;
                    screen          = PointToScreen(new Point(0, 0));
                }
            }
            else
            {
                screen          = e.Location;
                isHeaderContext = PointToClient(e.Location).Y < HeaderHeight;
            }

            IAnkhCommandService sc = Context.GetService <IAnkhCommandService>();

            AnkhCommandMenu menu;

            if (isHeaderContext)
            {
                Select(); // Must be the active control for the menu to work
                menu = AnkhCommandMenu.ListViewHeader;
            }
            else
            {
                menu = AnkhCommandMenu.WorkingCopyExplorerContextMenu;
            }

            sc.ShowContextMenu(menu, screen);
        }
Exemple #18
0
        public void OnExecute(CommandEventArgs e)
        {
            if (_commandService == null)
            {
                _commandService = e.GetService <IAnkhCommandService>();
            }
            if (_projectTracker == null)
            {
                _projectTracker = e.GetService <ProjectTracker>();
            }
            if (_sccProvider == null)
            {
                _sccProvider = e.GetService <SvnSccProvider>(typeof(IAnkhSccService));
            }

            _commandService.TockCommand(e.Command);

            _projectTracker.OnSccCleanup(e);
            _sccProvider.OnSccCleanup(e);
        }
        protected override void Dispose(bool disposing)
        {
            ThreadHelper.ThrowIfNotOnUIThread();

            try
            {
                if (disposing)
                {
                    if (_mergeHooked)
                    {
                        _mergeHooked = false;

                        UnregisterHandler unregister = _unregister;

                        IAnkhCommandService cs = GetService <IAnkhCommandService>();
                        if (cs != null)
                        {
                            cs.PostIdleAction(delegate
                            {
                                unregister(_mergeCookie);
                            });
                        }
                    }

                    if (_frameHooked)
                    {
                        _frameHooked = false;
                        _frame2.Unadvise(_frameCookie);
                    }
                }

                // Unbreak possible circular dependency
                _frame      = null;
                _frame2     = null;
                _unregister = null;
            }
            finally
            {
                base.Dispose(disposing);
            }
        }
Exemple #20
0
        public override void OnShowContextMenu(MouseEventArgs e)
        {
            base.OnShowContextMenu(e);

            Point p        = e.Location;
            bool  showSort = false;

            if (p != new Point(-1, -1))
            {
                // Mouse context menu
                if (PointToClient(p).Y < HeaderHeight)
                {
                    showSort = true;
                }
            }
            else
            {
                ListViewItem fi = FocusedItem;

                if (fi != null)
                {
                    p = PointToScreen(fi.Position);
                }
            }

            IAnkhCommandService mcs = Context.GetService <IAnkhCommandService>();

            if (mcs != null)
            {
                if (showSort)
                {
                    mcs.ShowContextMenu(AnkhCommandMenu.PendingCommitsHeaderContextMenu, p);
                }
                else
                {
                    mcs.ShowContextMenu(AnkhCommandMenu.PendingCommitsContextMenu, p);
                }
            }
        }
Exemple #21
0
        public void OnExecute(CommandEventArgs e)
        {
            if (_commandService == null)
            {
                _commandService = e.GetService <IAnkhCommandService>();
            }
            if (_fileCache == null)
            {
                _fileCache = e.GetService <GitStatusCache>(typeof(IGitStatusCache));
            }

            _commandService.TockCommand(e.Command);

            if (e.Command == AnkhCommand.GitCacheFinishTasks)
            {
                _fileCache.OnCleanup();
            }
            else
            {
                _fileCache.BroadcastChanges();
            }
        }
        void OnExecuteFill(CommandEventArgs e)
        {
            if (ProjectRootUri != null)
            {
                e.Result = new string[] { ProjectRootUri.ToString(), "Other..." }
            }
            ;
        }

        void OnExecuteSet(CommandEventArgs e)
        {
            string value = (string)e.Argument;

            IAnkhCommandService cs = e.GetService <IAnkhCommandService>();

            if (value != null && value == "Other...")
            {
                cs.PostExecCommand(AnkhCommand.SolutionSwitchDialog);
            }
            else
            {
                cs.PostExecCommand(AnkhCommand.SolutionSwitchDialog, new Uri(value));
            }
        }

        void OnExecuteGet(CommandEventArgs e)
        {
            if (ProjectRootUri != null)
            {
                e.Result = ProjectRootUri.ToString();
            }
        }

        void OnExecuteFilter(CommandEventArgs e)
        {
            // Not called on us; but empty handler would tell: pass through
        }
    }
Exemple #23
0
        public override void OnShowContextMenu(MouseEventArgs e)
        {
            base.OnShowContextMenu(e);

            Point screen;

            if (e.X == -1 && e.Y == -1)
            {
                screen = GetSelectionPoint();
                if (screen.IsEmpty)
                {
                    return;
                }
            }
            else
            {
                screen = e.Location;
            }

            IAnkhCommandService sc = Context.GetService <IAnkhCommandService>();

            sc.ShowContextMenu(AnkhCommandMenu.WorkingCopyExplorerContextMenu, screen);
        }
Exemple #24
0
        private void OnResponse(IAsyncResult ar)
        {
            IAnkhConfigurationService config = Context.GetService <IAnkhConfigurationService>();
            bool   failed = true;
            string tag    = null;

            try
            {
                WebRequest  rq = ((WebRequest)ar.AsyncState);
                WebResponse wr;
                try
                {
                    wr = rq.EndGetResponse(ar);
                }
                catch (WebException e)
                {
                    HttpWebResponse hwr = e.Response as HttpWebResponse;

                    if (hwr != null)
                    {
                        if (hwr.StatusCode == HttpStatusCode.NotFound)
                        {
                            failed = false;
                            return; // File not found.. Update info not yet or no longer available
                        }
                    }

                    return;
                }
                catch
                {
                    return;
                }

                if (wr.ContentLength > 65536) // Not for us.. We expect a few hundred bytes max
                {
                    return;
                }

                string body;
                using (Stream s = wr.GetResponseStream())
                    using (StreamReader sr = new StreamReader(s))
                    {
                        body = sr.ReadToEnd().Trim();
                    }

                if (string.IsNullOrEmpty(body))
                {
                    failed = false;
                    return;
                }

                if (body[0] != '<' || body[body.Length - 1] != '>')
                {
                    return; // No valid xml or empty
                }
                failed = false;

                XmlDocument doc = new XmlDocument();
                doc.LoadXml(body);

                string title       = NodeText(doc, "/u/i/t");
                string header      = NodeText(doc, "/u/i/h") ?? title;
                string description = NodeText(doc, "/u/i/d");
                string url         = NodeText(doc, "/u/i/u");
                string urltext     = NodeText(doc, "/u/i/l");

                string version    = NodeText(doc, "/u/i/v");
                string newVersion = NodeText(doc, "/u/i/n") ?? version;

                tag = NodeText(doc, "/u/g");

                if (!string.IsNullOrEmpty(title) && !string.IsNullOrEmpty(description))
                {
                    if (!string.IsNullOrEmpty(version))
                    {
                        Version v = new Version(version);

                        if (v <= GetCurrentVersion(Context))
                        {
                            return;
                        }
                    }

                    if (!string.IsNullOrEmpty(tag))
                    {
                        using (RegistryKey rk = config.OpenUserInstanceKey("UpdateCheck"))
                        {
                            string pTag = rk.GetValue("SkipTag") as string;

                            if (pTag == tag)
                            {
                                return;
                            }
                        }
                    }

                    IAnkhCommandService cs = Context.GetService <IAnkhCommandService>();

                    cs.PostExecCommand(AnkhCommand.CheckForUpdates,
                                       new string[] { title, header, description, url, urltext, version, newVersion, tag });
                }
            }
            finally
            {
                using (RegistryKey rk = config.OpenUserInstanceKey("UpdateCheck"))
                {
                    object fails = rk.GetValue("Fails", 0);
                    rk.DeleteValue("LastCheck", false);
                    rk.DeleteValue("LastVersion", false);
                    rk.DeleteValue("FailedChecks", false);
                    rk.SetValue("LastCheck", DateTime.UtcNow.Ticks);
                    rk.SetValue("LastVersion", GetCurrentVersion(Context).ToString());
                    if (tag != null)
                    {
                        rk.SetValue("LastTag", tag);
                    }
                    else
                    {
                        rk.DeleteValue("LastTag", false);
                    }

                    if (failed)
                    {
                        int f = 0;
                        if (fails is int)
                        {
                            f = (int)fails + 1;
                        }

                        rk.SetValue("FailedChecks", f);
                    }
                }
            }
        }
Exemple #25
0
        private void openSccSelectorLink_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
        {
            IAnkhCommandService cs = Context.GetService <IAnkhCommandService>();

            cs.PostExecCommand(new CommandID(VSConstants.GUID_VSStandardCommandSet97, (int)VSConstants.VSStd97CmdID.ToolsOptions), "53544C4D-1D2D-44BD-8566-4FC149E23AAF");
        }
        void ShowPanel(PendingChangesPage page, bool select)
        {
            if (page == null)
            {
                throw new ArgumentNullException("page");
            }
            else if (page == _currentPage)
            {
                return;
            }

            bool foundPage = false;

            foreach (PendingChangesPage p in contentPanel.Controls)
            {
                if (p != page)
                {
                    p.Enabled = p.Visible = false;
                }
                else
                {
                    foundPage = true;
                    p.Enabled = p.Visible = true;

                    if (!p._alreadyThemed)
                    {
                        ThemePage(p);
                    }
                }
            }

            System.Diagnostics.Debug.Assert(foundPage);

            _currentPage = page;

            if (page != _activatePage)
            {
                _lastPage = page;
            }

            fileChangesButton.Checked   = (_lastPage == _commitsPage);
            issuesButton.Checked        = (_lastPage == _issuesPage);
            recentChangesButton.Checked = (_lastPage == _changesPage);
            conflictsButton.Checked     = (_lastPage == _conflictsPage);

            if (select)
            {
                page.Select();
            }

            if (Context != null)
            {
                IAnkhCommandService cmd = Context.GetService <IAnkhCommandService>();

                if (cmd != null)
                {
                    cmd.UpdateCommandUI(false);
                }

                UpdateCaption();
            }
        }
        public override void OnExecute(CommandEventArgs e)
        {
            ThreadHelper.ThrowIfNotOnUIThread();

            SvnItem node = EnumTools.GetFirst(e.Selection.GetSelectedSvnItems(false));

            IAnkhCommandService cmd = e.GetService <IAnkhCommandService>();

            switch (e.Command)
            {
            case AnkhCommand.ItemSelectInRepositoryExplorer:
                if (node == null || node.Uri == null)
                {
                    return;
                }

                if (cmd != null)
                {
                    cmd.DirectlyExecCommand(AnkhCommand.RepositoryBrowse, node.FullPath);
                }
                break;

            case AnkhCommand.ItemSelectInWorkingCopyExplorer:
                if (node == null || !node.Exists)
                {
                    return;
                }

                if (cmd != null)
                {
                    cmd.DirectlyExecCommand(AnkhCommand.WorkingCopyBrowse, node.FullPath);
                }
                break;

            case AnkhCommand.ItemSelectInFileExplorer:
                if (node == null || !node.Exists)
                {
                    return;
                }

                SelectInFileExplorer(node.FullPath);
                break;

            case AnkhCommand.ItemSelectInSolutionExplorer:
                if (node == null)
                {
                    return;
                }

                IVsUIHierarchyWindow hierWindow = VsShellUtilities.GetUIHierarchyWindow(e.Context, new Guid(ToolWindowGuids80.SolutionExplorer));

                IVsProject project = VsShellUtilities.GetProject(e.Context, node.FullPath) as IVsProject;

                if (hierWindow != null)
                {
                    int  found;
                    uint id;
                    VSDOCUMENTPRIORITY[] prio = new VSDOCUMENTPRIORITY[1];
                    if (project != null && VSErr.Succeeded(project.IsDocumentInProject(node.FullPath, out found, prio, out id)) && found != 0)
                    {
                        hierWindow.ExpandItem(project as IVsUIHierarchy, id, EXPANDFLAGS.EXPF_SelectItem);
                    }
                    else if (string.Equals(node.FullPath, e.Selection.SolutionFilename, StringComparison.OrdinalIgnoreCase))
                    {
                        hierWindow.ExpandItem(e.GetService <IVsUIHierarchy>(typeof(SVsSolution)), VSItemId.Root, EXPANDFLAGS.EXPF_SelectItem);
                    }

                    // Now try to activate the solution explorer
                    IVsWindowFrame solutionExplorer;
                    Guid           solutionExplorerGuid = new Guid(ToolWindowGuids80.SolutionExplorer);
                    IVsUIShell     shell = e.GetService <IVsUIShell>(typeof(SVsUIShell));

                    if (shell != null)
                    {
                        shell.FindToolWindow((uint)__VSFINDTOOLWIN.FTW_fForceCreate, ref solutionExplorerGuid, out solutionExplorer);

                        if (solutionExplorer != null)
                        {
                            solutionExplorer.Show();
                        }
                    }
                }
                break;
            }
        }
        private static void AutoOpenCommand(CommandEventArgs e, SvnItem item)
        {
            IProjectFileMapper    pfm = e.GetService <IProjectFileMapper>();
            IAnkhCommandService   svc = e.GetService <IAnkhCommandService>();
            IAnkhSolutionSettings solutionSettings = e.GetService <IAnkhSolutionSettings>();

            if (pfm == null || svc == null || solutionSettings == null)
            {
                return;
            }

            // We can assume we have a file

            if (pfm.IsProjectFileOrSolution(item.FullPath))
            {
                // Ok, the user selected the current solution file or an open project
                // Let's jump to it in the solution explorer

                svc.ExecCommand(AnkhCommand.ItemSelectInSolutionExplorer);
                return;
            }

            if (item.InSolution)
            {
                // The file is part of the solution, we can assume VS knows how to open it
                svc.ExecCommand(AnkhCommand.ItemOpenVisualStudio);
                return;
            }

            string filename = item.Name;
            string ext      = item.Extension;

            if (string.IsNullOrEmpty(ext))
            {
                // No extension -> Open as text
                svc.PostExecCommand(AnkhCommand.ItemOpenTextEditor);
                return;
            }

            foreach (string projectExt in solutionSettings.AllProjectExtensionsFilter.Split(';'))
            {
                if (projectExt.TrimStart('*').Trim().Equals(ext, StringComparison.OrdinalIgnoreCase))
                {
                    // We found a project or solution: Ask VS to open it

                    e.GetService <IAnkhSolutionSettings>().OpenProjectFile(item.FullPath);
                    return;
                }
            }

            bool odd = false;

            foreach (string block in solutionSettings.OpenFileFilter.Split('|'))
            {
                odd = !odd;
                if (odd)
                {
                    continue;
                }

                foreach (string itemExt in block.Split(';'))
                {
                    if (itemExt.TrimStart('*').Trim().Equals(ext, StringComparison.OrdinalIgnoreCase))
                    {
                        VsShellUtilities.OpenDocument(e.Context, item.FullPath);
                        return;
                    }
                }
            }

            // Ultimate fallback: Just open the file as windows would
            svc.PostExecCommand(AnkhCommand.ItemOpenWindows);
        }