private bool CheckDiffToolConfiguration()
        {
            DiffTool.Visible = true;
            string difftool = CommonLogic.GetGlobalDiffTool();

            if (string.IsNullOrEmpty(difftool))
            {
                RenderSettingUnset(DiffTool, DiffTool_Fix, _adviceDiffToolConfiguration.Text);
                return(false);
            }

            string cmd = GetGlobalSetting($"difftool.{difftool}.cmd");

            if (cmd.IsNullOrWhiteSpace())
            {
                cmd = MergeToolsHelper.DiffToolCmdSuggest(difftool, "");
                if (cmd.IsNullOrWhiteSpace())
                {
                    RenderSettingUnset(DiffTool, DiffTool_Fix, _adviceDiffToolConfiguration.Text);
                    return(false);
                }
            }

            RenderSettingSet(DiffTool, DiffTool_Fix, string.Format(_diffToolXConfigured.Text, difftool));
            return(true);
        }
        private bool CheckMergeTool()
        {
            MergeTool.Visible = true;
            string mergetool = CommonLogic.GetGlobalMergeTool();

            if (string.IsNullOrEmpty(mergetool))
            {
                RenderSettingUnset(MergeTool, MergeTool_Fix, _configureMergeTool.Text);
                return(false);
            }

            // Hardcode parameters to some mergetools
            if (EnvUtils.RunningOnWindows())
            {
                if (mergetool.ToLowerInvariant() == "kdiff3")
                {
                    string p = GetGlobalSetting($"mergetool.{mergetool}.path");
                    if (string.IsNullOrEmpty(p) || !File.Exists(p))
                    {
                        RenderSettingUnset(MergeTool, MergeTool_Fix, string.Format(_mergeToolXConfiguredNeedsCmd.Text, mergetool));
                        return(false);
                    }

                    RenderSettingSet(MergeTool, MergeTool_Fix, string.Format(_customMergeToolXConfigured.Text, mergetool));
                    return(true);
                }

                if (mergetool.ToLowerInvariant() == "tmerge")
                {
                    string p = GetGlobalSetting($"mergetool.{mergetool}.cmd");
                    if (string.IsNullOrEmpty(p))
                    {
                        RenderSettingUnset(MergeTool, MergeTool_Fix, string.Format(_mergeToolXConfiguredNeedsCmd.Text, mergetool));
                        return(false);
                    }

                    RenderSettingSet(MergeTool, MergeTool_Fix, string.Format(_customMergeToolXConfigured.Text, mergetool));
                    return(true);
                }
            }

            // This will check parameters for some tools only, the user may have to set the tool cmd
            string cmd = GetGlobalSetting($"mergetool.{mergetool}.cmd");

            if (cmd.IsNullOrWhiteSpace())
            {
                cmd = MergeToolsHelper.AutoConfigMergeToolCmd(mergetool, "");
                if (cmd.IsNullOrWhiteSpace())
                {
                    RenderSettingUnset(MergeTool, MergeTool_Fix, string.Format(_mergeToolXConfiguredNeedsCmd.Text, mergetool));
                    return(false);
                }
            }

            RenderSettingSet(MergeTool, MergeTool_Fix, string.Format(_mergeToolXConfigured.Text, mergetool));
            return(true);
        }
Exemplo n.º 3
0
        private void BrowseDiffTool_Click(object sender, EventArgs e)
        {
            string diffTool = _NO_TRANSLATE_GlobalDiffTool.Text.ToLowerInvariant();
            string exeFile  = MergeToolsHelper.GetDiffToolExeFile(diffTool);

            var filter = exeFile != null
                ? string.Format("{0} ({1})|{1}", _NO_TRANSLATE_GlobalDiffTool.Text, exeFile)
                : string.Format("{0} (*.exe)|*.exe", _NO_TRANSLATE_GlobalDiffTool.Text);

            DifftoolPath.Text = CommonLogic.SelectFile(".", filter, DifftoolPath.Text);
        }
Exemplo n.º 4
0
        public bool SolveMergeToolPathForKDiff()
        {
            string kdiff3path = MergeToolsHelper.FindPathForKDiff(_gitModule.GetGlobalSetting("mergetool.kdiff3.path"));

            if (string.IsNullOrEmpty(kdiff3path))
            {
                return(false);
            }

            _gitModule.SetGlobalPathSetting("mergetool.kdiff3.path", kdiff3path);
            return(true);
        }
        private void BrowseMergeTool_Click(object sender, EventArgs e)
        {
            string mergeTool = _NO_TRANSLATE_GlobalMergeTool.Text.ToLowerInvariant();
            string exeFile   = MergeToolsHelper.GetMergeToolExeFile(mergeTool);

            if (exeFile != null)
            {
                MergetoolPath.Text = CommonLogic.SelectFile(".", string.Format("{0} ({1})|{1}", _NO_TRANSLATE_GlobalMergeTool.Text, exeFile), MergetoolPath.Text);
            }
            else
            {
                MergetoolPath.Text = CommonLogic.SelectFile(".", string.Format("{0} (*.exe)|*.exe", _NO_TRANSLATE_GlobalMergeTool.Text), MergetoolPath.Text);
            }
        }
Exemplo n.º 6
0
        private static string GetEditorCommandLine(string editorName, string executableName, string commandLineParameter, params string[] installFolders)
        {
            string exec = MergeToolsHelper.FindFileInFolders(executableName, installFolders);

            if (String.IsNullOrEmpty(exec))
            {
                exec = editorName;
            }
            else
            {
                exec = "\"" + exec + "\"";
            }
            return(exec + commandLineParameter);
        }
Exemplo n.º 7
0
        private void BrowseDiffTool_Click(object sender, EventArgs e)
        {
            string diffTool = GlobalDiffTool.Text.ToLowerInvariant();
            string exeFile  = MergeToolsHelper.GetDiffToolExeFile(diffTool);

            if (exeFile != null)
            {
                DifftoolPath.Text = CommonLogic.SelectFile(".", string.Format("{0} ({1})|{1}", GlobalDiffTool.Text, exeFile), DifftoolPath.Text);
            }
            else
            {
                DifftoolPath.Text = CommonLogic.SelectFile(".", string.Format("{0} (*.exe)|*.exe", GlobalDiffTool.Text), DifftoolPath.Text);
            }
        }
Exemplo n.º 8
0
        private static string GetNotepadPP()
        {
            string npp = MergeToolsHelper.FindFileInFolders("notepad++.exe", "Notepad++");

            if (String.IsNullOrEmpty(npp))
            {
                npp = "notepad++";
            }
            else
            {
                npp = "\"" + npp + "\"";
            }
            npp = npp + " -multiInst -nosession";
            return(npp);
        }
Exemplo n.º 9
0
        private static string GetSublimeText3()
        {
            string exec = MergeToolsHelper.FindFileInFolders("sublime_text.exe", "Sublime Text 3");

            if (String.IsNullOrEmpty(exec))
            {
                exec = "SublimeText";
            }
            else
            {
                exec = "\"" + exec + "\"";
            }
            //http://stackoverflow.com/questions/8951275/git-config-core-editor-how-to-make-sublime-text-the-default-editor-for-git-on
            exec = exec + " -w --multiinstance";
            return(exec);
        }
        private void ResolveDiffToolPath()
        {
            string kdiff3Path = MergeToolsHelper.FindPathForKDiff(CurrentSettings.GetValue("difftool.kdiff3.path"));

            if (string.IsNullOrEmpty(kdiff3Path))
            {
                return;
            }

            kdiff3Path = MergeToolsHelper.FindFileInFolders("kdiff3.exe", MergetoolPath.Text);
            if (string.IsNullOrEmpty(kdiff3Path))
            {
                return;
            }

            DifftoolPath.Text = kdiff3Path;
        }
Exemplo n.º 11
0
        private void ResolveDiffToolPath()
        {
            string kdiff3path = MergeToolsHelper.FindPathForKDiff(_gitModule.GetGlobalSetting("difftool.kdiff3.path"));

            if (string.IsNullOrEmpty(kdiff3path))
            {
                return;
            }

            kdiff3path = MergeToolsHelper.FindFileInFolders("kdiff3.exe", MergetoolPath.Text);
            if (string.IsNullOrEmpty(kdiff3path))
            {
                return;
            }

            DifftoolPath.Text = kdiff3path;
        }
Exemplo n.º 12
0
        protected override void Init(ISettingsPageHost aPageHost)
        {
            base.Init(aPageHost);

            CommonLogic.FillEncodings(Global_FilesEncoding);

            string npp = MergeToolsHelper.FindFileInFolders("notepad++.exe", "Notepad++");

            if (string.IsNullOrEmpty(npp))
            {
                npp = "notepad++";
            }
            else
            {
                npp = "\"" + npp + "\"";
            }

            GlobalEditor.Items.AddRange(new Object[] { "\"" + AppSettings.GetGitExtensionsFullPath() + "\" fileeditor", "vi", "notepad", npp + " -multiInst -nosession" });
        }
        private void DiffToolCmdSuggest_Click(object sender, EventArgs e)
        {
            if (!EnvUtils.RunningOnWindows())
            {
                return;
            }

            var diffToolPath = DifftoolPath.Text.Trim().Trim('"', '\'');

            CurrentSettings.SetPathValue(string.Format("difftool.{0}.path", _NO_TRANSLATE_GlobalDiffTool.Text.Trim()), diffToolPath ?? "");
            string exeName;
            string exeFile;

            if (!string.IsNullOrEmpty(diffToolPath))
            {
                exeFile = diffToolPath;
                exeName = Path.GetFileName(exeFile);
            }
            else
            {
                exeFile = MergeToolsHelper.FindDiffToolFullPath(ConfigFileSettingsSet, _NO_TRANSLATE_GlobalDiffTool.Text, out exeName);
            }

            if (string.IsNullOrEmpty(exeFile))
            {
                DifftoolPath.SelectAll();
                DifftoolPath.SelectedText = "";
                DifftoolCmd.SelectAll();
                DifftoolCmd.SelectedText = "";
                if (sender != null)
                {
                    MessageBox.Show(this, string.Format(_toolSuggestPathText.Text, exeName),
                                    _diffToolSuggestCaption.Text);
                }

                return;
            }

            DifftoolPath.SelectAll(); // allow Undo action
            DifftoolPath.SelectedText = exeFile;
            DifftoolCmd.SelectAll();
            DifftoolCmd.SelectedText = MergeToolsHelper.DiffToolCmdSuggest(_NO_TRANSLATE_GlobalDiffTool.Text, exeFile);
        }
Exemplo n.º 14
0
        public void AutoConfigMergeToolCmd(bool silent)
        {
            string exeName;
            string exeFile = MergeToolsHelper.FindMergeToolFullPath(GetGlobalMergeToolText(), out exeName);

            if (String.IsNullOrEmpty(exeFile))
            {
                SetMergetoolPathText("");
                SetMergeToolCmdText("");
                if (!silent)
                {
                    MessageBox.Show(/*this, */ String.Format(_toolSuggestPath.Text, exeName),
                                    __mergeToolSuggestCaption.Text);
                }
                return;
            }

            SetMergetoolPathText(exeFile);
            SetMergeToolCmdText(MergeToolsHelper.AutoConfigMergeToolCmd(GetGlobalMergeToolText(), exeFile));
        }
        private void MergeToolCmdSuggest_Click(object sender, EventArgs e)
        {
            if (!EnvUtils.RunningOnWindows())
            {
                return;
            }

            CurrentSettings.SetPathValue(string.Format("mergetool.{0}.path", _NO_TRANSLATE_GlobalMergeTool.Text.Trim()), MergetoolPath.Text.Trim());
            string exeName;
            string exeFile;

            if (!string.IsNullOrEmpty(MergetoolPath.Text))
            {
                exeFile = MergetoolPath.Text;
                exeName = Path.GetFileName(exeFile);
            }
            else
            {
                exeFile = MergeToolsHelper.FindMergeToolFullPath(ConfigFileSettingsSet, _NO_TRANSLATE_GlobalMergeTool.Text, out exeName);
            }

            if (string.IsNullOrEmpty(exeFile))
            {
                MergetoolPath.SelectAll();
                MergetoolPath.SelectedText = "";
                MergeToolCmd.SelectAll();
                MergeToolCmd.SelectedText = "";
                if (sender != null)
                {
                    MessageBox.Show(this, string.Format(_toolSuggestPathText.Text, exeName),
                                    _mergeToolSuggestCaption.Text);
                }

                return;
            }

            MergetoolPath.SelectAll(); // allow Undo action
            MergetoolPath.SelectedText = exeFile;
            MergeToolCmd.SelectAll();
            MergeToolCmd.SelectedText = MergeToolsHelper.MergeToolcmdSuggest(_NO_TRANSLATE_GlobalMergeTool.Text, exeFile);
        }
Exemplo n.º 16
0
        public GlobalSettingsSettingsPage(CommonLogic commonLogic, CheckSettingsLogic checkSettingsLogic, GitModule gitModule)
            : this()
        {
            _commonLogic        = commonLogic;
            _checkSettingsLogic = checkSettingsLogic;
            _gitModule          = gitModule;

            _commonLogic.FillEncodings(Global_FilesEncoding);

            string npp = MergeToolsHelper.FindFileInFolders("notepad++.exe", "Notepad++");

            if (string.IsNullOrEmpty(npp))
            {
                npp = "notepad++";
            }
            else
            {
                npp = "\"" + npp + "\"";
            }

            GlobalEditor.Items.AddRange(new Object[] { "\"" + Settings.GetGitExtensionsFullPath() + "\" fileeditor", "vi", "notepad", npp + " -multiInst -nosession" });
        }
Exemplo n.º 17
0
        private void DiffToolCmdSuggest_Click(object sender, EventArgs e)
        {
            if (!EnvUtils.RunningOnWindows())
            {
                return;
            }

            CurrentSettings.SetPathValue(string.Format("difftool.{0}.path", GlobalMergeTool.Text.Trim()), MergetoolPath.Text.Trim());
            string exeName;
            string exeFile;

            if (!String.IsNullOrEmpty(DifftoolPath.Text))
            {
                exeFile = DifftoolPath.Text;
                exeName = Path.GetFileName(exeFile);
            }
            else
            {
                exeFile = MergeToolsHelper.FindDiffToolFullPath(ConfigFileSettingsSet, GlobalDiffTool.Text, out exeName);
            }
            if (String.IsNullOrEmpty(exeFile))
            {
                DifftoolPath.SelectAll();
                DifftoolPath.SelectedText = "";
                DifftoolCmd.SelectAll();
                DifftoolCmd.SelectedText = "";
                if (sender != null)
                {
                    MessageBox.Show(this, String.Format(CheckSettingsLogic.ToolSuggestPathText.Text, exeName),
                                    __diffToolSuggestCaption.Text);
                }
                return;
            }
            DifftoolPath.SelectAll(); // allow Undo action
            DifftoolPath.SelectedText = exeFile;
            DifftoolCmd.SelectAll();
            DifftoolCmd.SelectedText = MergeToolsHelper.DiffToolCmdSuggest(GlobalDiffTool.Text, exeFile);
        }
Exemplo n.º 18
0
        private void MergeToolCmdSuggest_Click(object sender, EventArgs e)
        {
            if (!EnvUtils.RunningOnWindows())
            {
                return;
            }

            _gitModule.SetGlobalPathSetting(string.Format("mergetool.{0}.path", GlobalMergeTool.Text.Trim()), MergetoolPath.Text.Trim());
            string exeName;
            string exeFile;

            if (!String.IsNullOrEmpty(MergetoolPath.Text))
            {
                exeFile = MergetoolPath.Text;
                exeName = Path.GetFileName(exeFile);
            }
            else
            {
                exeFile = MergeToolsHelper.FindMergeToolFullPath(GlobalMergeTool.Text, out exeName);
            }
            if (String.IsNullOrEmpty(exeFile))
            {
                MergetoolPath.SelectAll();
                MergetoolPath.SelectedText = "";
                MergeToolCmd.SelectAll();
                MergeToolCmd.SelectedText = "";
                if (sender != null)
                {
                    MessageBox.Show(this, String.Format(_checkSettingsLogic.ToolSuggestPathText.Text, exeName),
                                    _checkSettingsLogic.MergeToolSuggestCaption.Text);
                }
                return;
            }
            MergetoolPath.SelectAll(); // allow Undo action
            MergetoolPath.SelectedText = exeFile;
            MergeToolCmd.SelectAll();
            MergeToolCmd.SelectedText = MergeToolsHelper.MergeToolcmdSuggest(GlobalMergeTool.Text, exeFile);
        }