init lserp cs 5.0

2026-07-10 15:25:05 +08:00
commit 90f3fda86a
3799 changed files with 976868 additions and 0 deletions
@@ -0,0 +1,300 @@
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using Cef3.Interop;
+
+    /// <summary>
+    /// Class used to create and/or parse command line arguments. Arguments with
+    /// '--', '-' and, on Windows, '/' prefixes are considered switches. Switches
+    /// will always precede any arguments without switch prefixes. Switches can
+    /// optionally have a value specified using the '=' delimiter (e.g.
+    /// "-switch=value"). An argument of "--" will terminate switch parsing with all
+    /// subsequent tokens, regardless of prefix, being interpreted as non-switch
+    /// arguments. Switch names are considered case-insensitive. This class can be
+    /// used before CefInitialize() is called.
+    /// </summary>
+    public sealed unsafe partial class CefCommandLine
+    {
+        /// <summary>
+        /// Create a new CefCommandLine instance.
+        /// </summary>
+        public static CefCommandLine Create()
+        {
+            return CefCommandLine.FromNative(cef_command_line_t.create());
+        }
+
+        /// <summary>
+        /// Returns the singleton global CefCommandLine object. The returned object
+        /// will be read-only.
+        /// </summary>
+        public static CefCommandLine Global
+        {
+            get
+            {
+                // FIXME: looks, like this method asserts inside in cef debug version - 'cause global cmdline is not yet set?
+                return CefCommandLine.FromNative(cef_command_line_t.get_global());
+            }
+        }
+
+
+        /// <summary>
+        /// Returns true if this object is valid. Do not call any other methods if this
+        /// function returns false.
+        /// </summary>
+        public bool IsValid
+        {
+            get { return cef_command_line_t.is_valid(_self) != 0; }
+        }
+
+        /// <summary>
+        /// Returns true if the values of this object are read-only. Some APIs may
+        /// expose read-only objects.
+        /// </summary>
+        public bool IsReadOnly
+        {
+            get { return cef_command_line_t.is_read_only(_self) != 0; }
+        }
+
+        /// <summary>
+        /// Returns a writable copy of this object.
+        /// </summary>
+        public CefCommandLine Copy()
+        {
+            return CefCommandLine.FromNative(cef_command_line_t.copy(_self));
+        }
+
+        // fixme: what with InitFromArgv ?
+        // <summary>
+        // Initialize the command line with the specified |argc| and |argv| values.
+        // The first argument must be the name of the program. This method is only
+        // supported on non-Windows platforms.
+        // </summary>
+        // public void InitFromArgv(int argc, const char* const* argv) =0;
+
+        // fixme: what with InitFromString ?
+        // <summary>
+        // Initialize the command line with the string returned by calling
+        // GetCommandLineW(). This method is only supported on Windows.
+        // </summary>
+        // public void InitFromString(const CefString& command_line) =0;
+
+        /// <summary>
+        /// Reset the command-line switches and arguments but leave the program
+        /// component unchanged.
+        /// </summary>
+        public void Reset()
+        {
+            cef_command_line_t.reset(_self);
+        }
+
+        /// <summary>
+        /// Retrieve the original command line string as a vector of strings.
+        /// The argv array: { program, [(--|-|/)switch[=value]]*, [--], [argument]* }
+        /// </summary>
+        public string[] GetArgv()
+        {
+            var list = libcef.string_list_alloc();
+            cef_command_line_t.get_argv(_self, list);
+            var result = cef_string_list.ToArray(list);
+            libcef.string_list_free(list);
+            return result;
+        }
+
+        /// <summary>
+        /// Constructs and returns the represented command line string. Use this method
+        /// cautiously because quoting behavior is unclear.
+        /// </summary>
+        public override string ToString()
+        {
+            return cef_string_userfree.ToString(
+                cef_command_line_t.get_command_line_string(_self)
+                );
+        }
+
+        /// <summary>
+        /// Get the program part of the command line string (the first item).
+        /// </summary>
+        public string GetProgram()
+        {
+            return cef_string_userfree.ToString(
+                cef_command_line_t.get_program(_self)
+                ) ?? "";
+        }
+
+        /// <summary>
+        /// Set the program part of the command line string (the first item).
+        /// </summary>
+        public void SetProgram(string value)
+        {
+            // if (value == null) throw new ArgumentNullException("value");
+
+            fixed (char* value_str = value)
+            {
+                var n_value = new cef_string_t(value_str, value != null ? value.Length : 0);
+
+                cef_command_line_t.set_program(_self, &n_value);
+            }
+        }
+
+        /// <summary>
+        /// Returns true if the command line has switches.
+        /// </summary>
+        public bool HasSwitches
+        {
+            get { return cef_command_line_t.has_switches(_self) != 0; }
+        }
+
+        /// <summary>
+        /// Returns true if the command line contains the given switch.
+        /// </summary>
+        public bool HasSwitch(string name)
+        {
+            // TODO: use CheckSwitchName method
+
+            fixed (char* name_str = name)
+            {
+                var n_name = new cef_string_t(name_str, name.Length);
+
+                return cef_command_line_t.has_switch(_self, &n_name) != 0;
+            }
+        }
+
+        /// <summary>
+        /// Returns the value associated with the given switch. If the switch has no
+        /// value or isn't present this method returns the empty string.
+        /// </summary>
+        public string GetSwitchValue(string name)
+        {
+            // TODO: use CheckSwitchName method
+
+            fixed (char* name_str = name)
+            {
+                var n_name = new cef_string_t(name_str, name.Length);
+
+                return cef_string_userfree.ToString(
+                    cef_command_line_t.get_switch_value(_self, &n_name)
+                    );
+            }
+        }
+
+        /// <summary>
+        /// Returns the map of switch names and values. If a switch has no value an
+        /// empty string is returned.
+        /// </summary>
+        public IDictionary<string, string> GetSwitches()
+        {
+            var switches = libcef.string_map_alloc();
+            cef_command_line_t.get_switches(_self, switches);
+            var result = cef_string_map.ToDictionary(switches);
+            libcef.string_map_free(switches);
+            return result;
+        }
+
+        /// <summary>
+        /// Add a switch to the end of the command line. If the switch has no value
+        /// pass an empty value string.
+        /// </summary>
+        public void AppendSwitch(string name)
+        {
+            // TODO: use CheckSwitchName method
+            if (StringHelper.IsNullOrWhiteSpace(name))
+            {
+                if (name == null) throw new ArgumentNullException("name");
+                throw new ArgumentException("Switch name must be non empty or whitespace only string.", "name");
+            }
+
+            fixed (char* name_str = name)
+            {
+                var n_name = new cef_string_t(name_str, name.Length);
+
+                cef_command_line_t.append_switch(_self, &n_name);
+            }
+        }
+
+        /// <summary>
+        /// Add a switch with the specified value to the end of the command line.
+        /// </summary>
+        public void AppendSwitch(string name, string value)
+        {
+            // TODO: use CheckSwitchName method
+            if (StringHelper.IsNullOrWhiteSpace(name))
+            {
+                if (name == null) throw new ArgumentNullException("name");
+                throw new ArgumentException("Switch name must be non empty or whitespace only string.", "name");
+            }
+
+            fixed (char* name_str = name)
+            fixed (char* value_str = value)
+            {
+                var n_name = new cef_string_t(name_str, name.Length);
+                var n_value = new cef_string_t(value_str, value != null ? value.Length : 0);
+
+                cef_command_line_t.append_switch_with_value(_self, &n_name, &n_value);
+            }
+        }
+
+        /// <summary>
+        /// True if there are remaining command line arguments.
+        /// </summary>
+        public bool HasArguments
+        {
+            get { return cef_command_line_t.has_arguments(_self) != 0; }
+        }
+
+        /// <summary>
+        /// Get the remaining command line arguments.
+        /// </summary>
+        public string[] GetArguments()
+        {
+            var arguments = libcef.string_list_alloc();
+            cef_command_line_t.get_arguments(_self, arguments);
+            var result = cef_string_list.ToArray(arguments);
+            libcef.string_list_free(arguments);
+            return result;
+        }
+
+        /// <summary>
+        /// Add an argument to the end of the command line.
+        /// </summary>
+        public void AppendArgument(string value)
+        {
+            fixed (char* value_str = value)
+            {
+                var n_value = new cef_string_t(value_str, value.Length);
+
+                cef_command_line_t.append_argument(_self, &n_value);
+            }
+        }
+
+        /// <summary>
+        /// Insert a command before the current command.
+        /// Common for debuggers, like "valgrind" or "gdb --args".
+        /// </summary>
+        public void PrependWrapper(string wrapper)
+        {
+            fixed (char* wrapper_str = wrapper)
+            {
+                var n_wrapper = new cef_string_t(wrapper_str, wrapper.Length);
+
+                cef_command_line_t.prepend_wrapper(_self, &n_wrapper);
+            }
+        }
+
+        /// <summary>
+        /// Insert an argument to the beginning of the command line.
+        /// Unlike PrependWrapper this method doesn't strip argument by spaces.
+        /// </summary>
+        public void PrependArgument(string argument)
+        {
+            if (argument.IndexOf(' ') >= 0)
+            {
+                // When argument contains spaces, we just prepend command line with dummy wrapper
+                // and then replace it with actual argument.
+                PrependWrapper(".");
+                SetProgram(argument);
+            }
+            else PrependWrapper(argument);
+        }
+    }
+}