IsMono() public static method

Returns true if the app is running on Mono (Linux), false if it is Windows
public static IsMono ( ) : bool
return bool
コード例 #1
0
ファイル: ClassHttpsPasswd.cs プロジェクト: pausan/GitForce
        /// <summary>
        /// Constructor creates a shell executable file that echoes the PASSWORD
        /// environment variable when called. When GIT_ASKPASS is present, Git
        /// obtains a password for its HTTPS operations by calling it.
        /// </summary>
        public ClassHttpsPasswd()
        {
            // WAR: Do a different kind of shell script dependent on the OS)
            string pathPasswordBatchHelper;

            if (ClassUtils.IsMono())
            {
                // Mono: Use the Shell script which tests if $PASSWORD is defined and echoes it,
                // and if not defined, it calls GitForce application with a special argument that opens
                // only password dialog
                pathPasswordBatchHelper = Path.Combine(App.AppHome, "passwd.sh");
                File.WriteAllText(pathPasswordBatchHelper, "#!/bin/sh" + Environment.NewLine +
                                  "if [ \"$PASSWORD\" = \"\" ]; then" + Environment.NewLine +
                                  App.AppPath + " --passwd" + Environment.NewLine +
                                  "else" + Environment.NewLine +
                                  "echo $PASSWORD" + Environment.NewLine +
                                  "fi");
                // Set the execute bit
                if (Exec.Run("chmod", "+x " + pathPasswordBatchHelper).Success() == false)
                {
                    App.PrintLogMessage("ClassHttpsPasswd: Unable to chmod +x on " + pathPasswordBatchHelper, MessageType.Error);
                }
            }
            else
            {
                // Windows: Use the CMD BAT script
                // Note: Using "App.AppHome" directory to host the batch helper file
                //       fails on XP where that directory has spaces in the name ("Documents and Settings")
                //       which git cannot handle in this context. Similarly, git will fail with
                //       any other path that contains a space.
                // This redirection is used to provide the password in an automated way.
                pathPasswordBatchHelper = Path.Combine(Path.GetTempPath(), "passwd.bat");
                File.WriteAllText(pathPasswordBatchHelper, "@echo %PASSWORD%" + Environment.NewLine);
                pathPasswordBatchHelper = ClassUtils.GetShortPathName(pathPasswordBatchHelper);
            }
            ClassUtils.AddEnvar("GIT_ASKPASS", pathPasswordBatchHelper);

            App.PrintLogMessage("Created HTTP password helper file: " + pathPasswordBatchHelper, MessageType.General);
        }
コード例 #2
0
        public FormLog()
        {
            InitializeComponent();
            ClassWinGeometry.Restore(this);

            // Add our main print function callback delegate
            App.PrintLogMessage += Print;

            // WAR: On Linux, remove status bar resizing grip (since it does not work under X)
            if (ClassUtils.IsMono())
            {
                statusStrip.SizingGrip = false;
            }

            if (App.AppLog != null)
            {
                Print("Logging: " + App.AppLog, MessageType.General);
            }

            // Prints only in Debug build...
            Debug("Debug build.");
        }
コード例 #3
0
ファイル: FormEditTools.cs プロジェクト: pokam-dev/GitForce
        public FormEditTools(ClassTool tool)
        {
            InitializeComponent();
            ClassWinGeometry.Restore(this);
            Tool = (ClassTool)tool.Clone();

            textName.Text = tool.Name;
            textCmd.Text  = tool.Cmd;
            textArgs.Text = tool.Args;
            textDir.Text  = tool.Dir;
            textDesc.Text = tool.Desc;
            checkAddToContextMenu.Checked = tool.IsAddToContextMenu;
            checkConsoleApp.Checked       = tool.IsConsoleApp;
            checkWriteToStatus.Checked    = tool.IsWriteOutput;
            checkCloseUponExit.Checked    = tool.IsCloseWindowOnExit;
            checkRefresh.Checked          = tool.IsRefresh;
            checkPrompt.Checked           = tool.IsPromptForArgs;
            checkBrowse.Checked           = tool.IsAddBrowse;

            // TODO: Running a command line tool largely does not work on Linux at the moment
            if (ClassUtils.IsMono())
            {
                checkWriteToStatus.Enabled = checkCloseUponExit.Enabled = false;
                checkWriteToStatus.Checked = checkCloseUponExit.Checked = false;
                checkConsoleApp.Checked    = true; // FIXME: Some success when this is checked
            }

            // Adjust the enables (in this order)
            CheckCloseUponExitCheckedChanged(null, null);
            CheckConsoleAppCheckedChanged(null, null);

            // Set the width of drop-down portions of help combo box so when it expands (down)
            // it will show horizontally the complete text from all pre-defined lines.
            // Also set their tags to point to the buddy edit boxes into which to insert selected tokens.
            SetComboBoxWidth(comboHelpArg);
            comboHelpArg.Tag = textArgs;
            SetComboBoxWidth(comboHelpDir);
            comboHelpDir.Tag = textDir;
        }
コード例 #4
0
ファイル: FormGitRun.cs プロジェクト: Celebrate/GitForce
        /// <summary>
        /// Class constructor that also pre-sets the command and argument to be run
        /// </summary>
        public FormGitRun(string cmd, string args)
        {
            InitializeComponent();
            ClassWinGeometry.Restore(this);
            checkAutoclose.Checked = Properties.Settings.Default.AutoCloseGitOnSuccess;

            // WAR: On Linux, remove status bar resizing grip (since it does not work under X)
            if (ClassUtils.IsMono())
            {
                statusStrip.SizingGrip = false;
            }

            // Detect URL in this text box
            textStdout.DetectUrls = true;

            job = new Exec(cmd, args);

            // Reuse the same font selected as fixed-pitch
            textStdout.Font  = Properties.Settings.Default.commitFont;
            textStdout.Text += cmd + Environment.NewLine;
            textStdout.Text += args + Environment.NewLine;
        }
コード例 #5
0
        /// <summary>
        /// This function is called when text boxes name and URL changed.
        /// It calls delegate back to the caller.
        /// </summary>
        private void SomeTextChanged(object sender, EventArgs e)
        {
            // Call the delegate and also reparse our fetch and push URLs
            AnyTextChanged(IsValid());

            // Enable SSH button if one of the URLs uses SSH connection
            btSsh.Enabled = false;
            if (_fetchUrl.Ok && _fetchUrl.Type == ClassUrl.UrlType.Ssh)
            {
                btSsh.Enabled = true;
            }
            if (_pushUrl.Ok && _pushUrl.Type == ClassUrl.UrlType.Ssh)
            {
                btSsh.Enabled = true;
            }
            btWWW1.Enabled = _fetchUrl.Ok;
            btWWW2.Enabled = _pushUrl.Ok;

            textPassword.ReadOnly = !(_fetchUrl.Type == ClassUrl.UrlType.Https || _pushUrl.Type == ClassUrl.UrlType.Https);

            // WAR: Permanently disable SSH button if not on Windows OS
            btSsh.Enabled = !ClassUtils.IsMono();
        }
コード例 #6
0
ファイル: ClassCommandLine.cs プロジェクト: pausan/GitForce
        /// <summary>
        /// The main execution function for command line arguments.
        /// Returns 'false' if the main program should not continue with the execution, in which
        /// case ReturnCode contains the return code to return to the OS.
        /// </summary>
        public static bool Execute(Arguments commandLine)
        {
            // WAR: On Windows, re-attach the console so we can print. Mono does not need that to use Console class.
            if (!ClassUtils.IsMono())
            {
                NativeMethods.AttachConsole();
                Console.WriteLine(Environment.NewLine);
            }

            if (commandLine["help"] == "true" || commandLine["?"] == "true")
            {
                Console.WriteLine(Environment.NewLine +
                                  "GitForce optional arguments:" + Environment.NewLine +
                                  "  --version             Show the application version number." + Environment.NewLine +
                                  "  --reset-windows       Reset stored locations of windows and dialogs." + Environment.NewLine +
                                  "  --reset-config        Reset program configuration (repos etc.)." + Environment.NewLine +
                                  "  --log                 Logs debug output to file." + Environment.NewLine);
                ReturnCode  = 0;
                runGitForce = false;
            }

            // --version Show the application version number and quit
            if (commandLine["version"] == "true")
            {
                Console.WriteLine("GitForce version " + ClassVersion.GetVersion());
                ReturnCode  = 0;
                runGitForce = false;
            }

            // --reset-windows  Reset stored locations and sizes of all windows and dialogs
            if (commandLine["reset-windows"] == "true")
            {
                Properties.Settings.Default.WindowsGeometries = new StringCollection();
                Properties.Settings.Default.Save();
                Console.WriteLine("GitForce windows and dialogs geometries have been reset.");
                ReturnCode  = 0;
                runGitForce = true;
            }

            // --reset-config   Reset stored configuration items (repos, settings)
            if (commandLine["reset-config"] == "true")
            {
                List <string> toWhack = new List <string>();

                // This is very much dependent on the platform, load a list of directories to whack appropriately
                if (ClassUtils.IsMono())
                {
                    string home = Environment.GetEnvironmentVariable("HOME");
                    if (!string.IsNullOrEmpty(home))
                    {
                        toWhack.Add(Path.Combine(home, ".config/GitForce"));
                        toWhack.Add(Path.Combine(home, ".local/share/GitForce"));
                    }
                }
                else
                {
                    toWhack.Add(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "GitForce"));
                    toWhack.Add(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "GitForce"));
                }
                // Now that we have a list of directories to remove, delete them
                foreach (var dir in toWhack)
                {
                    DirectoryInfo dirInfo = new DirectoryInfo(dir);
                    if (ClassUtils.DeleteFolder(dirInfo, false, false) == false)
                    {
                        Console.Write("Unable to delete some files!");
                    }
                }
                Console.WriteLine("Configuration has been reset.");
                ReturnCode  = 0;
                runGitForce = false;
            }

            // --log   Create a log file and append all debug log messages to it
            if (commandLine["log"] == "true")
            {
                App.AppLog = Path.Combine(App.AppHome, "gitforce.log");
                File.WriteAllText(App.AppLog, "Log created on " + DateTime.Now.ToShortDateString() + Environment.NewLine);
                Console.WriteLine("Logging: " + App.AppLog);
            }

            // --passwd  This is not a user option. It is used when the app is called to provide password echoed on a command line.
            if (commandLine["passwd"] == "true")
            {
                ReturnCode = -1;
                FormHttpsAuth httpsAuth = new FormHttpsAuth(false);
                if (httpsAuth.ShowDialog() == DialogResult.OK)
                {
                    Console.WriteLine(httpsAuth.Password);
                    ReturnCode = 0;
                }
                runGitForce = false;
            }

            // WAR: On Windows, detach the console when we are done. Mono does not need that to use Console class.
            if (!ClassUtils.IsMono())
            {
                NativeMethods.FreeConsole();
            }

            return(runGitForce);
        }
コード例 #7
0
        static int Main(string[] args)
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            // Upgrade application settings across the version increment
            ClassUtils.UpgradeApplicationSettingsIfNecessary();

            // Make sure the application data folder directory exists
            Directory.CreateDirectory(AppHome);

            // Get and process command line arguments
            Arguments commandLine = new Arguments(args);

            // If the processing requested program termination,
            // return using the error code created by that class
            if (ClassCommandLine.Execute(commandLine) == false)
            {
                return(ClassCommandLine.ReturnCode);
            }

            // Check that only one application instance is running
            bool  mAcquired;
            Mutex mAppMutex = new Mutex(true, "gitforce", out mAcquired);

            if (!mAcquired && Properties.Settings.Default.WarnMultipleInstances)
            {
                if (MessageBox.Show("GitForce is already running.\n\nDo you want to open a new instance?", "Warning",
                                    MessageBoxButtons.YesNo, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button2) == DialogResult.No)
                {
                    return(-1);
                }
            }

            // Check if the application has been run as Admin/root
            if (ClassUtils.IsAdmin())
            {
                if (MessageBox.Show("GitForce has been run with elevated privileges which is not a recomended way to run it.\n\nDo you still want to continue?", "Warning",
                                    MessageBoxButtons.YesNo, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button2) == DialogResult.No)
                {
                    return(-1);
                }
            }

            // Initialize logging and git execute support
            Log = new FormLog();
            Log.ShowWindow(Properties.Settings.Default.ShowLogWindow);

            Git = new ClassGit();

            // Before we can start, we need to have a functional git executable);
            if (Git.Initialize())
            {
                // Initialize external diff program
                Diff = new ClassDiff();
                if (Diff.Initialize())
                {
                    Merge = new ClassMerge();
                    // Initialize external Merge program
                    if (Merge.Initialize())
                    {
                        // Add known text editors
                        Settings.Panels.ControlViewEdit.AddKnownEditors();

                        if (ClassUtils.IsMono())
                        {
                            Ssh = new ClassSSH();           // Instantiate SSH support only on Linux (Mono)
                        }
                        else
                        {
                            Putty = new ClassPutty();         // Instantiate PuTTY support only on Windows
                        }
                        HttpsPasswd = new ClassHttpsPasswd(); // Create HTTPS password helper file
                        Repos       = new ClassRepos();       // Create repository canvas
                        Version     = new ClassVersion();     // Start the new version check process
                        MainForm    = new FormMain();         // Create the main form
                        MainForm.Show();                      // Show the main window so the handles get created
                        if (MainForm.Initialize())            // Load repos, custom tools etc.
                        {
                            DoRefresh();                      // Initial global refresh
                            Application.Run(MainForm);        // Run the main form

                            Properties.Settings.Default.Save();

                            GC.KeepAlive(mAppMutex);
                            return(0);
                        }
                    }
                }
            }
            return(-1);
        }
コード例 #8
0
ファイル: FormMain.cs プロジェクト: Celebrate/GitForce
        /// <summary>
        /// This is the main entry point to the application main form.
        /// </summary>
        public FormMain()
        {
            InitializeComponent();
            ClassWinGeometry.Restore(this);

            // WAR: On Linux, remove status bar resizing grip (since it does not work under X)
            if (ClassUtils.IsMono())
            {
                statusStrip.SizingGrip = false;
            }

            // Initialize panels
            // Left panel:
            splitContainer2.Panel1.Controls.Add(PanelView);
            PanelView.Dock = DockStyle.Fill;

            // Right set of panels:
            foreach (var panel in PanelsR)
            {
                var tabPage = new TabPage(panel.Key)
                {
                    Name = panel.Key, Tag = panel.Key, ToolTipText = panel.Key + " (" + PanelsRShortcuts[panel.Key] + ")"
                };
                panel.Value.Dock = DockStyle.Fill;
                tabPage.Controls.Add(panel.Value);
                rightTabControl.TabPages.Add(tabPage);
            }

            // Show or hide command line
            menuViewCommandLine.Checked = cmdBox.Visible = Properties.Settings.Default.ShowCommandLine;

            UpdateRightPaneTabsShowState();

            // Enable SSH only if the PuTTY support class has been instantiated
            if (App.Putty != null)
            {
                btSsh.Enabled = true;
                menuMainManageKeys.Enabled = true;
            }

            // We prevent Log window form closing by getting a FormClosing event within which we set "e.Cancel" to True
            App.Log.FormClosing      += LogWindowToolStripMenuItemClick;
            menuViewLogWindow.Checked = Properties.Settings.Default.ShowLogWindow;

            // Add all callback handlers
            App.Refresh            += FormMainRefresh; // Refresh, when any component wants to update the global state
            App.PrintStatusMessage += PrintStatus;     // Print a line of status message
            App.StatusBusy         += SetBusy;         // Busy flag set or reset

            // Register toolbar file buttons with the View panel
            PanelView.RegisterToolstripFileButtons(new Dictionary
                                                   <PanelView.FileOps, ToolStripButton>
            {
                { PanelView.FileOps.Add, btAdd },
                { PanelView.FileOps.Update, btUpdate },
                { PanelView.FileOps.UpdateAll, btUpdateAll },
                { PanelView.FileOps.Revert, btRevert },
                { PanelView.FileOps.Delete, btDelete },
                { PanelView.FileOps.DeleteFs, btDeleteFs },
                { PanelView.FileOps.Edit, btEdit }
            });

            PrintStatus("GitForce version " + ClassVersion.GetVersion(), MessageType.General);

            // Arm the timer that will check for the result of the new version test
            // Since the network access, implemented in ClassVersion, can take some time to
            // provide with the version check result, we will simply repaint our icon after a delay
            Timer versionCheckTimer = new Timer {
                Interval = 10000, Enabled = true
            };

            versionCheckTimer.Tick += VersionCheckTimerTick;
        }