cyf
301 lines
10 KiB
C#
301 lines
10 KiB
C#
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);
|
|
}
|
|
}
|
|
}
|