/// <summary>
/// The default log handler set up by GLib; <see cref="SetDefaultHandler"/>
/// allows to install an alternate default log handler.
/// </summary>
/// <param name="logDomain">the log domain, or <see langword="null" /> for the default "" application domain</param>
/// <param name="logLevel">the level of the message</param>
/// <param name="message">the message</param>
public static void DefaultHandler(string logDomain, Enums.LogLevelFlags logLevel, string message)
{
var nmess = message.ToUtf8Ptr();
GLib.GLogDefaultHandler(logDomain, logLevel, nmess, IntPtr.Zero);
GLib.GFree(nmess);
}
/// <summary>
/// Logs an error or debugging message.
/// </summary>
/// <param name="logDomain">the log domain, or <see langword="null" /> for the default "" application domain</param>
/// <param name="flags">the log level</param>
/// <param name="format">the message format</param>
/// <param name="args">the parameters to insert into the format string</param>
public static void WriteLog(string logDomain, Enums.LogLevelFlags flags, string format, params object[] args)
{
var nmessage = string.Format(format, args).ToUtf8Ptr();
GLib.GLogv(logDomain, flags, nmessage);
GLib.GFree(nmessage);
}
private void Invoke(string logDomain, Enums.LogLevelFlags flags, string message)
{
var ndom = logDomain.ToUtf8Ptr();
var nmess = message.ToUtf8Ptr();
native(ndom, flags, nmess, IntPtr.Zero);
GLib.GFree(ndom);
GLib.GFree(nmess);
}
/// <summary>
/// Sets the log handler for a domain and a set of log levels.
/// </summary>
/// <param name="logDomain">The log domain, or <see langword="null"/> for the default "" application domain.</param>
/// <param name="flags">The log levels to apply the log handler for.</param>
/// <param name="logFunc">The log handler function.</param>
/// <returns>The id of the handler.</returns>
public static uint SetLogHandler(string logDomain, Enums.LogLevelFlags flags, LogDelegate logFunc)
{
_nativeHandler ??= NativeCallback;
var gch = GCHandle.Alloc(logFunc);
var result = GLib.GLogSetHandler(logDomain, flags, _nativeHandler, (IntPtr)gch);
_handlers.AddOrUpdate(result, gch, (k, v) => gch);
return(result);
}
private static void NativeCallback(IntPtr logDomainNative, Enums.LogLevelFlags flags, IntPtr messageNative,
IntPtr userData)
{
if (userData == IntPtr.Zero)
{
return;
}
var logDomain = logDomainNative.ToUtf8String();
var message = messageNative.ToUtf8String();
var gch = (GCHandle)userData;
if (gch.Target is LogFunc func)
{
func(logDomain, flags, message);
}
}
/// <summary>
/// Common logging method.
/// </summary>
/// <remarks>
/// Sample usage:
/// <code language="lang-csharp">
/// // Print messages and stack trace for vips critical messages
/// var logFunc = new LogFunc(Log.PrintTraceLogFunction);
/// Log.SetLogHandler("VIPS", Enums.LogLevelFlags.Critical, logFunc);
/// </code>
/// </remarks>
/// <param name="domain">the log domain of the message</param>
/// <param name="level">the log level of the message (including the fatal and recursion flags)</param>
/// <param name="message">the message to process</param>
public static void PrintTraceLogFunction(string domain, Enums.LogLevelFlags level, string message)
{
PrintLogFunction(domain, level, message);
Console.WriteLine("Trace follows:\n{0}", new StackTrace());
}
/// <summary>
/// Common logging method.
/// </summary>
/// <remarks>
/// Sample usage:
/// <code language="lang-csharp">
/// // Print the messages for the NULL domain
/// var logFunc = new LogFunc(Log.PrintLogFunction);
/// Log.SetLogHandler(null, Enums.LogLevelFlags.All, logFunc);
/// </code>
/// </remarks>
/// <param name="domain">the log domain of the message</param>
/// <param name="level">the log level of the message (including the fatal and recursion flags)</param>
/// <param name="message">the message to process</param>
public static void PrintLogFunction(string domain, Enums.LogLevelFlags level, string message)
{
Console.WriteLine("Domain: '{0}' Level: {1}", domain, level);
Console.WriteLine("Message: {0}", message);
}
/// <summary>
/// Sets the log levels which are fatal in the given domain.
/// </summary>
/// <param name="logDomain">the log domain</param>
/// <param name="fatalMask">the new fatal mask</param>
/// <returns>the old fatal mask for the log domain</returns>
public static Enums.LogLevelFlags SetAlwaysFatal(string logDomain, Enums.LogLevelFlags fatalMask)
{
return(GLib.GLogSetFatalMask(logDomain, fatalMask));
}
/// <summary>
/// Sets the message levels which are always fatal, in any log domain.
/// When a message with any of these levels is logged the program terminates.
/// </summary>
/// <param name="fatalMask">the mask containing bits set for each level of error which is to be fatal</param>
/// <returns>the old fatal mask</returns>
public static Enums.LogLevelFlags SetAlwaysFatal(Enums.LogLevelFlags fatalMask)
{
return(GLib.GLogSetAlwaysFatal(fatalMask));
}
