// Package gio was automatically generated by github.com/bnema/puregotk DO NOT EDIT
package gio

import (
	"unsafe"

	"github.com/ebitengine/purego"

	"github.com/bnema/puregotk/pkg/core"
	"github.com/bnema/puregotk/v4/glib"
	"github.com/bnema/puregotk/v4/gobject"
	"github.com/bnema/puregotk/v4/gobject/types"
)

// This class contains a set of options for launching child processes,
// such as where its standard input and output will be directed, the
// argument list, the environment, and more.
//
// While the [class@Gio.Subprocess] class has high level functions covering
// popular cases, use of this class allows access to more advanced
// options.  It can also be used to launch multiple subprocesses with
// a similar configuration.
type SubprocessLauncher struct {
	gobject.Object
}

var xSubprocessLauncherGLibType func() types.GType

func SubprocessLauncherGLibType() types.GType {
	return xSubprocessLauncherGLibType()
}

func SubprocessLauncherNewFromInternalPtr(ptr uintptr) *SubprocessLauncher {
	cls := &SubprocessLauncher{}
	cls.Ptr = ptr
	return cls
}

var xNewSubprocessLauncher func(SubprocessFlags) uintptr

// Creates a new #GSubprocessLauncher.
//
// The launcher is created with the default options.  A copy of the
// environment of the calling process is made at the time of this call
// and will be used as the environment that the process is launched in.
func NewSubprocessLauncher(FlagsVar SubprocessFlags) *SubprocessLauncher {
	var cls *SubprocessLauncher

	cret := xNewSubprocessLauncher(FlagsVar)

	if cret == 0 {
		return nil
	}
	cls = &SubprocessLauncher{}
	cls.Ptr = cret
	return cls
}

var xSubprocessLauncherClose func(uintptr)

// Closes all the file descriptors previously passed to the object with
// g_subprocess_launcher_take_fd(), g_subprocess_launcher_take_stderr_fd(), etc.
//
// After calling this method, any subsequent calls to g_subprocess_launcher_spawn() or g_subprocess_launcher_spawnv() will
// return %G_IO_ERROR_CLOSED. This method is idempotent if
// called more than once.
//
// This function is called automatically when the #GSubprocessLauncher
// is disposed, but is provided separately so that garbage collected
// language bindings can call it earlier to guarantee when FDs are closed.
func (x *SubprocessLauncher) Close() {

	xSubprocessLauncherClose(x.GoPointer())

}

var xSubprocessLauncherGetenv func(uintptr, string) string

// Returns the value of the environment variable @variable in the
// environment of processes launched from this launcher.
//
// On UNIX, the returned string can be an arbitrary byte string.
// On Windows, it will be UTF-8.
func (x *SubprocessLauncher) Getenv(VariableVar string) string {

	cret := xSubprocessLauncherGetenv(x.GoPointer(), VariableVar)
	return cret
}

var xSubprocessLauncherSetChildSetup func(uintptr, uintptr, uintptr, uintptr)

// Sets up a child setup function.
//
// The child setup function will be called after fork() but before
// exec() on the child's side.
//
// @destroy_notify will not be automatically called on the child's side
// of the fork().  It will only be called when the last reference on the
// #GSubprocessLauncher is dropped or when a new child setup function is
// given.
//
// %NULL can be given as @child_setup to disable the functionality.
//
// Child setup functions are only available on UNIX.
func (x *SubprocessLauncher) SetChildSetup(ChildSetupVar *glib.SpawnChildSetupFunc, UserDataVar uintptr, DestroyNotifyVar *glib.DestroyNotify) {

	var ChildSetupVarRef uintptr
	if ChildSetupVar != nil {
		ChildSetupVarPtr := uintptr(unsafe.Pointer(ChildSetupVar))
		if cbRefPtr, ok := glib.GetCallback(ChildSetupVarPtr); ok {
			ChildSetupVarRef = cbRefPtr
		} else {
			fcb := func(arg0 uintptr) {
				cbFn := *ChildSetupVar
				cbFn(arg0)
			}
			ChildSetupVarRef = purego.NewCallback(fcb)
			glib.SaveCallbackWithClosure(ChildSetupVarPtr, ChildSetupVarRef, ChildSetupVar)
		}
	}

	var DestroyNotifyVarRef uintptr
	if DestroyNotifyVar != nil {
		DestroyNotifyVarPtr := uintptr(unsafe.Pointer(DestroyNotifyVar))
		if cbRefPtr, ok := glib.GetCallback(DestroyNotifyVarPtr); ok {
			DestroyNotifyVarRef = cbRefPtr
		} else {
			fcb := func(arg0 uintptr) {
				cbFn := *DestroyNotifyVar
				cbFn(arg0)
			}
			DestroyNotifyVarRef = purego.NewCallback(fcb)
			glib.SaveCallbackWithClosure(DestroyNotifyVarPtr, DestroyNotifyVarRef, DestroyNotifyVar)
		}
	}

	xSubprocessLauncherSetChildSetup(x.GoPointer(), ChildSetupVarRef, UserDataVar, DestroyNotifyVarRef)

}

var xSubprocessLauncherSetCwd func(uintptr, string)

// Sets the current working directory that processes will be launched
// with.
//
// By default processes are launched with the current working directory
// of the launching process at the time of launch.
func (x *SubprocessLauncher) SetCwd(CwdVar string) {

	xSubprocessLauncherSetCwd(x.GoPointer(), CwdVar)

}

var xSubprocessLauncherSetEnviron func(uintptr, []string)

// Replace the entire environment of processes launched from this
// launcher with the given 'environ' variable.
//
// Typically you will build this variable by using g_listenv() to copy
// the process 'environ' and using the functions g_environ_setenv(),
// g_environ_unsetenv(), etc.
//
// As an alternative, you can use g_subprocess_launcher_setenv(),
// g_subprocess_launcher_unsetenv(), etc.
//
// Pass an empty array to set an empty environment. Pass %NULL to inherit the
// parent process’ environment. As of GLib 2.54, the parent process’ environment
// will be copied when g_subprocess_launcher_set_environ() is called.
// Previously, it was copied when the subprocess was executed. This means the
// copied environment may now be modified (using g_subprocess_launcher_setenv(),
// etc.) before launching the subprocess.
//
// On UNIX, all strings in this array can be arbitrary byte strings.
// On Windows, they should be in UTF-8.
func (x *SubprocessLauncher) SetEnviron(EnvVar []string) {

	xSubprocessLauncherSetEnviron(x.GoPointer(), EnvVar)

}

var xSubprocessLauncherSetFlags func(uintptr, SubprocessFlags)

// Sets the flags on the launcher.
//
// The default flags are %G_SUBPROCESS_FLAGS_NONE.
//
// You may not set flags that specify conflicting options for how to
// handle a particular stdio stream (eg: specifying both
// %G_SUBPROCESS_FLAGS_STDIN_PIPE and
// %G_SUBPROCESS_FLAGS_STDIN_INHERIT).
//
// You may also not set a flag that conflicts with a previous call to a
// function like g_subprocess_launcher_set_stdin_file_path() or
// g_subprocess_launcher_take_stdout_fd().
func (x *SubprocessLauncher) SetFlags(FlagsVar SubprocessFlags) {

	xSubprocessLauncherSetFlags(x.GoPointer(), FlagsVar)

}

var xSubprocessLauncherSetStderrFilePath func(uintptr, uintptr)

// Sets the file path to use as the stderr for spawned processes.
//
// If @path is %NULL then any previously given path is unset.
//
// The file will be created or truncated when the process is spawned, as
// would be the case if using '2>' at the shell.
//
// If you want to send both stdout and stderr to the same file then use
// %G_SUBPROCESS_FLAGS_STDERR_MERGE.
//
// You may not set a stderr file path if a stderr fd is already set or
// if the launcher flags contain any flags directing stderr elsewhere.
//
// This feature is only available on UNIX.
func (x *SubprocessLauncher) SetStderrFilePath(PathVar *string) {

	PathVarPtr := core.GStrdupNullable(PathVar)
	defer core.GFreeNullable(PathVarPtr)

	xSubprocessLauncherSetStderrFilePath(x.GoPointer(), PathVarPtr)

}

var xSubprocessLauncherSetStdinFilePath func(uintptr, uintptr)

// Sets the file path to use as the stdin for spawned processes.
//
// If @path is %NULL then any previously given path is unset.
//
// The file must exist or spawning the process will fail.
//
// You may not set a stdin file path if a stdin fd is already set or if
// the launcher flags contain any flags directing stdin elsewhere.
//
// This feature is only available on UNIX.
func (x *SubprocessLauncher) SetStdinFilePath(PathVar *string) {

	PathVarPtr := core.GStrdupNullable(PathVar)
	defer core.GFreeNullable(PathVarPtr)

	xSubprocessLauncherSetStdinFilePath(x.GoPointer(), PathVarPtr)

}

var xSubprocessLauncherSetStdoutFilePath func(uintptr, uintptr)

// Sets the file path to use as the stdout for spawned processes.
//
// If @path is %NULL then any previously given path is unset.
//
// The file will be created or truncated when the process is spawned, as
// would be the case if using '>' at the shell.
//
// You may not set a stdout file path if a stdout fd is already set or
// if the launcher flags contain any flags directing stdout elsewhere.
//
// This feature is only available on UNIX.
func (x *SubprocessLauncher) SetStdoutFilePath(PathVar *string) {

	PathVarPtr := core.GStrdupNullable(PathVar)
	defer core.GFreeNullable(PathVarPtr)

	xSubprocessLauncherSetStdoutFilePath(x.GoPointer(), PathVarPtr)

}

var xSubprocessLauncherSetenv func(uintptr, string, string, bool)

// Sets the environment variable @variable in the environment of
// processes launched from this launcher.
//
// On UNIX, both the variable's name and value can be arbitrary byte
// strings, except that the variable's name cannot contain '='.
// On Windows, they should be in UTF-8.
func (x *SubprocessLauncher) Setenv(VariableVar string, ValueVar string, OverwriteVar bool) {

	xSubprocessLauncherSetenv(x.GoPointer(), VariableVar, ValueVar, OverwriteVar)

}

var xSubprocessLauncherSpawn func(uintptr, **glib.Error, string, ...interface{}) uintptr

// Creates a #GSubprocess given a provided varargs list of arguments.
func (x *SubprocessLauncher) Spawn(ErrorVar **glib.Error, Argv0Var string, varArgs ...interface{}) *Subprocess {
	var cls *Subprocess

	cret := xSubprocessLauncherSpawn(x.GoPointer(), ErrorVar, Argv0Var, varArgs...)

	if cret == 0 {
		return nil
	}
	cls = &Subprocess{}
	cls.Ptr = cret
	return cls
}

var xSubprocessLauncherSpawnv func(uintptr, []string, **glib.Error) uintptr

// Creates a #GSubprocess given a provided array of arguments.
func (x *SubprocessLauncher) Spawnv(ArgvVar []string) (*Subprocess, error) {
	var cls *Subprocess
	var cerr *glib.Error

	cret := xSubprocessLauncherSpawnv(x.GoPointer(), ArgvVar, &cerr)

	if cret == 0 {
		return nil, cerr
	}
	cls = &Subprocess{}
	cls.Ptr = cret
	if cerr == nil {
		return cls, nil
	}
	return cls, cerr

}

var xSubprocessLauncherTakeFd func(uintptr, int, int)

// Transfer an arbitrary file descriptor from parent process to the
// child.  This function takes ownership of the @source_fd; it will be closed
// in the parent when @self is freed.
//
// By default, all file descriptors from the parent will be closed.
// This function allows you to create (for example) a custom `pipe()` or
// `socketpair()` before launching the process, and choose the target
// descriptor in the child.
//
// An example use case is GNUPG, which has a command line argument
// `--passphrase-fd` providing a file descriptor number where it expects
// the passphrase to be written.
func (x *SubprocessLauncher) TakeFd(SourceFdVar int, TargetFdVar int) {

	xSubprocessLauncherTakeFd(x.GoPointer(), SourceFdVar, TargetFdVar)

}

var xSubprocessLauncherTakeStderrFd func(uintptr, int)

// Sets the file descriptor to use as the stderr for spawned processes.
//
// If @fd is -1 then any previously given fd is unset.
//
// Note that the default behaviour is to pass stderr through to the
// stderr of the parent process.
//
// The passed @fd belongs to the #GSubprocessLauncher.  It will be
// automatically closed when the launcher is finalized.  The file
// descriptor will also be closed on the child side when executing the
// spawned process.
//
// You may not set a stderr fd if a stderr file path is already set or
// if the launcher flags contain any flags directing stderr elsewhere.
//
// This feature is only available on UNIX.
func (x *SubprocessLauncher) TakeStderrFd(FdVar int) {

	xSubprocessLauncherTakeStderrFd(x.GoPointer(), FdVar)

}

var xSubprocessLauncherTakeStdinFd func(uintptr, int)

// Sets the file descriptor to use as the stdin for spawned processes.
//
// If @fd is -1 then any previously given fd is unset.
//
// Note that if your intention is to have the stdin of the calling
// process inherited by the child then %G_SUBPROCESS_FLAGS_STDIN_INHERIT
// is a better way to go about doing that.
//
// The passed @fd is noted but will not be touched in the current
// process.  It is therefore necessary that it be kept open by the
// caller until the subprocess is spawned.  The file descriptor will
// also not be explicitly closed on the child side, so it must be marked
// O_CLOEXEC if that's what you want.
//
// You may not set a stdin fd if a stdin file path is already set or if
// the launcher flags contain any flags directing stdin elsewhere.
//
// This feature is only available on UNIX.
func (x *SubprocessLauncher) TakeStdinFd(FdVar int) {

	xSubprocessLauncherTakeStdinFd(x.GoPointer(), FdVar)

}

var xSubprocessLauncherTakeStdoutFd func(uintptr, int)

// Sets the file descriptor to use as the stdout for spawned processes.
//
// If @fd is -1 then any previously given fd is unset.
//
// Note that the default behaviour is to pass stdout through to the
// stdout of the parent process.
//
// The passed @fd is noted but will not be touched in the current
// process.  It is therefore necessary that it be kept open by the
// caller until the subprocess is spawned.  The file descriptor will
// also not be explicitly closed on the child side, so it must be marked
// O_CLOEXEC if that's what you want.
//
// You may not set a stdout fd if a stdout file path is already set or
// if the launcher flags contain any flags directing stdout elsewhere.
//
// This feature is only available on UNIX.
func (x *SubprocessLauncher) TakeStdoutFd(FdVar int) {

	xSubprocessLauncherTakeStdoutFd(x.GoPointer(), FdVar)

}

var xSubprocessLauncherUnsetenv func(uintptr, string)

// Removes the environment variable @variable from the environment of
// processes launched from this launcher.
//
// On UNIX, the variable's name can be an arbitrary byte string not
// containing '='. On Windows, it should be in UTF-8.
func (x *SubprocessLauncher) Unsetenv(VariableVar string) {

	xSubprocessLauncherUnsetenv(x.GoPointer(), VariableVar)

}

func (c *SubprocessLauncher) GoPointer() uintptr {
	if c == nil {
		return 0
	}
	return c.Ptr
}

func (c *SubprocessLauncher) SetGoPointer(ptr uintptr) {
	c.Ptr = ptr
}

func init() {
	core.SetPackageName("GIO", "gio-2.0")
	core.SetSharedLibraries("GIO", []string{"libgio-2.0.so.0"})
	var libs []uintptr
	for _, libPath := range core.GetPaths("GIO") {
		lib, err := purego.Dlopen(libPath, purego.RTLD_NOW|purego.RTLD_GLOBAL)
		if err != nil {
			panic(err)
		}
		libs = append(libs, lib)
	}

	core.PuregoSafeRegister(&xSubprocessLauncherGLibType, libs, "g_subprocess_launcher_get_type")

	core.PuregoSafeRegister(&xNewSubprocessLauncher, libs, "g_subprocess_launcher_new")

	core.PuregoSafeRegister(&xSubprocessLauncherClose, libs, "g_subprocess_launcher_close")
	core.PuregoSafeRegister(&xSubprocessLauncherGetenv, libs, "g_subprocess_launcher_getenv")
	core.PuregoSafeRegister(&xSubprocessLauncherSetChildSetup, libs, "g_subprocess_launcher_set_child_setup")
	core.PuregoSafeRegister(&xSubprocessLauncherSetCwd, libs, "g_subprocess_launcher_set_cwd")
	core.PuregoSafeRegister(&xSubprocessLauncherSetEnviron, libs, "g_subprocess_launcher_set_environ")
	core.PuregoSafeRegister(&xSubprocessLauncherSetFlags, libs, "g_subprocess_launcher_set_flags")
	core.PuregoSafeRegister(&xSubprocessLauncherSetStderrFilePath, libs, "g_subprocess_launcher_set_stderr_file_path")
	core.PuregoSafeRegister(&xSubprocessLauncherSetStdinFilePath, libs, "g_subprocess_launcher_set_stdin_file_path")
	core.PuregoSafeRegister(&xSubprocessLauncherSetStdoutFilePath, libs, "g_subprocess_launcher_set_stdout_file_path")
	core.PuregoSafeRegister(&xSubprocessLauncherSetenv, libs, "g_subprocess_launcher_setenv")
	core.PuregoSafeRegister(&xSubprocessLauncherSpawn, libs, "g_subprocess_launcher_spawn")
	core.PuregoSafeRegister(&xSubprocessLauncherSpawnv, libs, "g_subprocess_launcher_spawnv")
	core.PuregoSafeRegister(&xSubprocessLauncherTakeFd, libs, "g_subprocess_launcher_take_fd")
	core.PuregoSafeRegister(&xSubprocessLauncherTakeStderrFd, libs, "g_subprocess_launcher_take_stderr_fd")
	core.PuregoSafeRegister(&xSubprocessLauncherTakeStdinFd, libs, "g_subprocess_launcher_take_stdin_fd")
	core.PuregoSafeRegister(&xSubprocessLauncherTakeStdoutFd, libs, "g_subprocess_launcher_take_stdout_fd")
	core.PuregoSafeRegister(&xSubprocessLauncherUnsetenv, libs, "g_subprocess_launcher_unsetenv")

}