/usr/include/d/gtkd-3/glib/Child.d is in libgtkd-3-dev 3.7.5-2build1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 | /*
* This file is part of gtkD.
*
* gtkD is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 3
* of the License, or (at your option) any later version, with
* some exceptions, please read the COPYING file.
*
* gtkD is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with gtkD; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
*/
// generated automatically - do not change
// find conversion definition on APILookup.txt
// implement new conversion functionalities on the wrap.utils pakage
module glib.Child;
private import glib.Source;
private import glib.c.functions;
public import glib.c.types;
public import gtkc.glibtypes;
/** */
public struct Child
{
/**
* Sets a function to be called when the child indicated by @pid
* exits, at a default priority, #G_PRIORITY_DEFAULT.
*
* If you obtain @pid from g_spawn_async() or g_spawn_async_with_pipes()
* you will need to pass #G_SPAWN_DO_NOT_REAP_CHILD as flag to
* the spawn function for the child watching to work.
*
* Note that on platforms where #GPid must be explicitly closed
* (see g_spawn_close_pid()) @pid must not be closed while the
* source is still active. Typically, you will want to call
* g_spawn_close_pid() in the callback function for the source.
*
* GLib supports only a single callback per process id.
*
* This internally creates a main loop source using
* g_child_watch_source_new() and attaches it to the main loop context
* using g_source_attach(). You can do these steps manually if you
* need greater control.
*
* Params:
* pid = process id to watch. On POSIX the positive pid of a child
* process. On Windows a handle for a process (which doesn't have to be
* a child).
* funct = function to call
* data = data to pass to @function
*
* Returns: the ID (greater than 0) of the event source.
*
* Since: 2.4
*/
public static uint childWatchAdd(GPid pid, GChildWatchFunc funct, void* data)
{
return g_child_watch_add(pid, funct, data);
}
/**
* Sets a function to be called when the child indicated by @pid
* exits, at the priority @priority.
*
* If you obtain @pid from g_spawn_async() or g_spawn_async_with_pipes()
* you will need to pass #G_SPAWN_DO_NOT_REAP_CHILD as flag to
* the spawn function for the child watching to work.
*
* In many programs, you will want to call g_spawn_check_exit_status()
* in the callback to determine whether or not the child exited
* successfully.
*
* Also, note that on platforms where #GPid must be explicitly closed
* (see g_spawn_close_pid()) @pid must not be closed while the source
* is still active. Typically, you should invoke g_spawn_close_pid()
* in the callback function for the source.
*
* GLib supports only a single callback per process id.
*
* This internally creates a main loop source using
* g_child_watch_source_new() and attaches it to the main loop context
* using g_source_attach(). You can do these steps manually if you
* need greater control.
*
* Params:
* priority = the priority of the idle source. Typically this will be in the
* range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE.
* pid = process to watch. On POSIX the positive pid of a child process. On
* Windows a handle for a process (which doesn't have to be a child).
* funct = function to call
* data = data to pass to @function
* notify = function to call when the idle is removed, or %NULL
*
* Returns: the ID (greater than 0) of the event source.
*
* Since: 2.4
*/
public static uint childWatchAddFull(int priority, GPid pid, GChildWatchFunc funct, void* data, GDestroyNotify notify)
{
return g_child_watch_add_full(priority, pid, funct, data, notify);
}
/**
* Creates a new child_watch source.
*
* The source will not initially be associated with any #GMainContext
* and must be added to one with g_source_attach() before it will be
* executed.
*
* Note that child watch sources can only be used in conjunction with
* `g_spawn...` when the %G_SPAWN_DO_NOT_REAP_CHILD flag is used.
*
* Note that on platforms where #GPid must be explicitly closed
* (see g_spawn_close_pid()) @pid must not be closed while the
* source is still active. Typically, you will want to call
* g_spawn_close_pid() in the callback function for the source.
*
* Note further that using g_child_watch_source_new() is not
* compatible with calling `waitpid` with a nonpositive first
* argument in the application. Calling waitpid() for individual
* pids will still work fine.
*
* Similarly, on POSIX platforms, the @pid passed to this function must
* be greater than 0 (i.e. this function must wait for a specific child,
* and cannot wait for one of many children by using a nonpositive argument).
*
* Params:
* pid = process to watch. On POSIX the positive pid of a child process. On
* Windows a handle for a process (which doesn't have to be a child).
*
* Returns: the newly-created child watch source
*
* Since: 2.4
*/
public static Source childWatchSourceNew(GPid pid)
{
auto p = g_child_watch_source_new(pid);
if(p is null)
{
return null;
}
return new Source(cast(GSource*) p, true);
}
}
|