Vala Documentation

https://valadoc.org
Admin
Vala Documentation provides a comprehensive collection of API references and guides for various...
Tokens:5,286,337
Snippets:51,243
Trust Score:9.2
Update:3 months ago
Show doc for...
Tokens:
Raw
### Example Usage of AppInfo

Source: https://valadoc.org/gio-2.0/GLib.AppInfo.html

Demonstrates how to get a default AppInfo for a content type, check its capabilities, retrieve its command line and name, and launch it. Includes basic error handling.

```vala
public static int main (string[] args) {
	try {
		AppInfo appinfo = AppInfo.get_default_for_type ("text/x-vala", true);
		print ("%s\n", appinfo.supports_files ().to_string ());
		print ("%s\n", appinfo.supports_uris ().to_string ());
		print ("%s\n", appinfo.get_commandline ());
		print ("%s\n", appinfo.get_name ());
		appinfo.launch (null, null);
	} catch (Error e) {
		print ("Error: %s\n", e.message);
	}
	return 0;
}
```

--------------------------------

### Gtk.ListView Example

Source: https://valadoc.org/gtk4/Gtk.ListView.html

This example demonstrates how to set up and use Gtk.ListView with a custom item factory and signal handlers for item setup, binding, and activation. It requires creating a model, a factory, and connecting signals.

```c
static void setup_listitem_cb (GtkListItemFactory *factory, GtkListItem *list_item) {
    GtkWidget *image;

    image = gtk_image_new ();
    gtk_image_set_icon_size (GTK_IMAGE (image), GTK_ICON_SIZE_LARGE);
    gtk_list_item_set_child (list_item, image);
}
```

```c
static void bind_listitem_cb (GtkListItemFactory *factory, GtkListItem *list_item) {
    GtkWidget *image;
    GAppInfo *app_info;

    image = gtk_list_item_get_child (list_item);
    app_info = gtk_list_item_get_item (list_item);
    gtk_image_set_from_gicon (GTK_IMAGE (image), g_app_info_get_icon (app_info));
}
```

```c
static void activate_cb (GtkListView *list, guint position, gpointer unused) {
    GAppInfo *app_info;

    app_info = g_list_model_get_item (G_LIST_MODEL (gtk_list_view_get_model (list)), position);
    g_app_info_launch (app_info, NULL, NULL, NULL);
    g_object_unref (app_info);
}
```

```c
model = create_application_list ();
factory = gtk_signal_list_item_factory_new ();
g_signal_connect (factory, "setup", G_CALLBACK (setup_listitem_cb), NULL);
g_signal_connect ( factory, "bind", G_CALLBACK (bind_listitem_cb), NULL);

list = gtk_list_view_new (GTK_SELECTION_MODEL (gtk_single_selection_new (model)), factory);
g_signal_connect (list, "activate", G_CALLBACK (activate_cb), NULL);

gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), list);
```

--------------------------------

### GStreamer Device Monitoring Example

Source: https://valadoc.org/gstreamer-1.0/Gst.DeviceMonitor.html

This example demonstrates how to set up a GStreamer DeviceMonitor to track device additions and removals. It includes a bus function to process messages and a setup function to initialize the monitor with a video filter.

```c
static gboolean  
  my_bus_func (GstBus * bus, GstMessage * message, gpointer user_data)  
  {
     GstDevice *device;
     gchar *name;

     switch (GST_MESSAGE_TYPE (message)) {
       case GST_MESSAGE_DEVICE_ADDED:
         gst_message_parse_device_added (message, &device);
         name = gst_device_get_display_name (device);
         g_print("Device added: %s\n", name);
         g_free (name);
         gst_object_unref (device);
         break;
       case GST_MESSAGE_DEVICE_REMOVED:
         gst_message_parse_device_removed (message, &device);
         name = gst_device_get_display_name (device);
         g_print("Device removed: %s\n", name);
         g_free (name);
         gst_object_unref (device);
         break;
       default:
         break;
     }

     return G_SOURCE_CONTINUE;
  }
  
  GstDeviceMonitor *
  setup_raw_video_source_device_monitor (void) {
     GstDeviceMonitor *monitor;
     GstBus *bus;
     GstCaps *caps;

     monitor = gst_device_monitor_new ();

     bus = gst_device_monitor_get_bus (monitor);
     gst_bus_add_watch (bus, my_bus_func, NULL);
     gst_object_unref (bus);

     caps = gst_caps_new_empty_simple ("video/x-raw");
     gst_device_monitor_add_filter (monitor, "Video/Source", caps);
     gst_caps_unref (caps);

     gst_device_monitor_start (monitor);

     return monitor;
  }
```

--------------------------------

### Compile Vala KeyFile Example

Source: https://valadoc.org/glib-2.0/GLib.KeyFile.html

Command to compile a Vala program that uses GLib.KeyFile. Ensure the glib-2.0 package is installed.

```bash
valac --pkg glib-2.0 GLib.KeyFile.vala

```

--------------------------------

### Commandline Parsing Example

Source: https://valadoc.org/glib-2.0/GLib.OptionContext.html

This example demonstrates how to set up and parse command-line options using GLib.OptionContext. It defines various option types including flags, filenames, string arrays, doubles, int64s, and ints. Ensure the GLib package is installed and linked.

```vala
public class Main : Object {
	private static bool version = false;
	private static string? directory = null;
	[CCode (array_length = false, array_null_terminated = true)]
	private static string[]? importdirs = null;
	private static string? driver = null;
	[CCode (array_length = false, array_null_terminated = true)]
	private static string[]? import_packages = null;
	private static double numd = 0;
	private static int64 numi64 = 0;
	private static int numi = 0;

	private const GLib.OptionEntry[] options = {
		// --version
		{ "version", '\0', OptionFlags.NONE, OptionArg.NONE, ref version, "Display version number", null },

		// --directory FIlENAME || -o FILENAME
		{ "directory", 'o', OptionFlags.NONE, OptionArg.FILENAME, ref directory, "Output directory", "DIRECTORY" },
		// [--vapidir FILENAME]*
		{ "importdir", '\0', OptionFlags.NONE, OptionArg.FILENAME_ARRAY, ref importdirs, "Look for external documentation in DIRECTORY", "DIRECTORY..." },

		// --driver
		{ "driver", '\0', OptionFlags.NONE, OptionArg.STRING, ref driver, "Use the given driver", "DRIVER" },
		// [--import STRING]*
		{ "import", '\0', OptionFlags.NONE, OptionArg.STRING_ARRAY, ref import_packages, "Include binding for PACKAGE", "PACKAGE..." },

		// --double DOUBLE
		{ "double", '\0', OptionFlags.NONE, OptionArg.DOUBLE, ref numd, "double value", "DOUBLE" },
		// --int64 INT64
		{ "int64", '\0', OptionFlags.NONE, OptionArg.INT64, ref numi64, "int64 value", "INT64" },
		// --int INT
		{ "int", '\0', OptionFlags.NONE, OptionArg.INT, ref numi, "int value", "INT" },

		// list terminator
		{ null }
	};

	public static int main (string[] args) {
		try {
			var opt_context = new OptionContext ("- OptionContext example");
			opt_context.set_help_enabled (true);
			opt_context.add_main_entries (options, null);
			opt_context.parse (ref args);
		} catch (OptionError e) {
			printerr ("error: %s\n", e.message);
			printerr ("Run '%s --help' to see a full list of available command line options.\n", args[0]);
			return 1;
		}

		if (version) {
			print ("Test 0.1\n");
			return 0;
		}


		print ("Paths:\n");
		print (@" directory: '$directory'\n");
		print (" importdir: ");
		foreach (string str in importdirs) {
			print (@"'$str' ");
		}
		print ("\n\n");


		print ("Strings:\n");
		print (@" driver: '$driver'\n");
		print (" import: ");
		foreach (string str in import_packages) {
			print (@"'$str' ");
		}
		print ("\n\n");


		print ("Numeric:\n");
		print (@" double:  $numd\n");
		print (" int64:   %" + int64.FORMAT + "\n", numi64);
		print (@" int:     $numi\n");
		print (@" version: $version\n");

		// Help:
		//  ``Usage:``
		//  ``	test2 [OPTION...] - OptionContext example``
		//  ``
		//  ``	Help Options:``
		//  ``	  -h, --help                    Show help options``
		//  ``
		//  ``	Application Options:``
		//  ``	  --version                     Display version number``
		//  ``	  -o, --directory=DIRECTORY     Output directory``
		//  ``	  --importdir=DIRECTORY...      Look for external documentation in DIRECTORY``
		//  ``	  --driver=DRIVER               Use the given driver``
		//  ``	  --import=PACKAGE...           Include binding for PACKAGE``
		//  ``	  --double=DOUBLE               double value``
		//  ``	  --int64=INT64                 int64 value``
		//  ``	  --int=INT                     int value``

		return 0;
	}
}
```

--------------------------------

### Splitting Command Line Handling

Source: https://valadoc.org/gio-2.0/GLib.ApplicationCommandLine.html

This example shows how to split command-line handling between the launcher and the primary instance. Options starting with '--local-' are handled locally, while others are passed to the primary instance.

```APIDOC
## test_local_cmdline

### Description
Handles specific command-line arguments locally and determines whether to pass the rest to the primary instance.

### Method Signature
`static gboolean test_local_cmdline (GApplication *application, gchar ***arguments, gint *exit_status)`

### Parameters
- `application` (GApplication *): The application instance.
- `arguments` (gchar ***): A pointer to an array of command-line arguments.
- `exit_status` (gint *): A pointer to store the exit status.

### Return Value
`gboolean`: Returns `FALSE` to indicate that the command line should be further processed by the primary instance if not fully handled locally.

### Code Example
```c
static gboolean test_local_cmdline (GApplication *application, gchar ***arguments, gint *exit_status) {
    gint i, j;
    gchar **argv;

    argv = *arguments;
    if (argv[0] == NULL) {
        *exit_status = 0;
        return FALSE;
    }

    i = 1;
    while (argv[i]) {
        if (g_str_has_prefix (argv[i], "--local-")) {
            g_print ("handling argument %s locally\n", argv[i]);
            g_free (argv[i]);
            for (j = i; argv[j]; j++)
                argv[j] = argv[j + 1];
        } else {
            g_print ("not handling argument %s locally\n", argv[i]);
            i++;
        }
    }

    *exit_status = 0;
    return FALSE;
}

static void test_application_class_init (TestApplicationClass *class) {
    G_APPLICATION_CLASS (class)->local_command_line = test_local_cmdline;
    ...
}
```
```

--------------------------------

### GStreamer Hello World Example

Source: https://valadoc.org/gstreamer-1.0/Gst.State.html

Initializes GStreamer, builds and plays a pipeline, and then cleans up resources. This example demonstrates basic GStreamer pipeline management.

```vala
// See http://docs.gstreamer.com/x/NwAF  
// for a detailed description  
  
public static int main (string[] args) {  
	// Initialize GStreamer:  
Gst.init (ref args);  
  
  
	// Build the pipeline:  
	Gst.Element pipeline;  
	try {  
		pipeline = Gst.parse_launch ("playbin uri=http://docs.gstreamer.com/media/sintel_trailer-480p.webm");  
	} catch (Error e) {  
		stderr.printf ("Error: %s\n", e.message);  
		return 0;  
	}  
  
	// Start playing:  
	pipeline.set_state (Gst.State.PLAYING);  
  
	// Wait until error or EOS:  
	Gst.Bus bus = pipeline.get_bus ();  
bus.timed_pop_filtered (Gst.CLOCK_TIME_NONE, Gst.MessageType.ERROR | Gst.MessageType.EOS);  
  
	// Free resources:  
	pipeline.set_state (Gst.State.NULL);  
  
	return 0;  
}
```

--------------------------------

### Chained Asynchronous Operations Example

Source: https://valadoc.org/gio-2.0/GLib.Task.html

This example demonstrates how to chain multiple asynchronous operations using GTask. It includes setup for data structures, callback functions for different stages of the process (decoration, baking), and the main asynchronous function to start the cake baking process.

```c
typedef struct { Cake *cake; CakeFrostingType frosting; char *message; } BakingData;
```

```c
static void decoration_data_free (BakingData *bd) {
  if (bd->cake) g_object_unref (bd->cake);
  g_free (bd->message);
  g_slice_free ( BakingData, bd);
}
```

```c
static void decorated_cb (Cake *cake, GAsyncResult *result, gpointer user_data) {
  GTask *task = user_data;
  GError *error = NULL;

  if (!cake_decorate_finish (cake, result, &error)) {
    g_object_unref (cake);
    g_task_return_error (task, error);
    g_object_unref (task);
    return;
  }

  // `baking_data_free` will drop its ref on the cake, so we have to
  // take another here to give to the caller.
  g_task_return_pointer (task, g_object_ref (cake), g_object_unref);
  g_object_unref (task);
}
```

```c
static gboolean decorator_ready (gpointer user_data) {
  GTask *task = user_data;
  BakingData *bd = g_task_get_task_data (task);

  cake_decorate_async (bd->cake, bd->frosting, bd->message, g_task_get_cancellable (task), decorated_cb, task);

  return G_SOURCE_REMOVE;
}
```

```c
static void baked_cb (Cake *cake, gpointer user_data) {
  GTask *task = user_data;
  BakingData *bd = g_task_get_task_data (task);
  GError *error = NULL;

  if (cake == NULL) {
    g_task_return_new_error (task, BAKER_ERROR, BAKER_ERROR_NO_FLOUR, "Go to the supermarket");
    g_object_unref (task);
    return;
  }

  bd->cake = cake;

  // Bail out now if the user has already cancelled
  if (g_task_return_error_if_cancelled (task)) {
    g_object_unref (task);
    return;
  }

  if (cake_decorator_available (cake))
    decorator_ready (task);
  else {
    GSource *source;

    source = cake_decorator_wait_source_new (cake);
    // Attach `source` to `task`’s GMainContext and have it call
    // `decorator_ready` when it is ready.
    g_task_attach_source (task, source, decorator_ready);
    g_source_unref (source);
  }
}
```

```c
void baker_bake_cake_async (Baker *self, guint radius, CakeFlavor flavor, CakeFrostingType frosting, const char *message, gint priority, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) {
  GTask *task;
  BakingData *bd;

  task = g_task_new (self, cancellable, callback, user_data);
  g_task_set_priority (task, priority);

  bd = g_slice_new0 (BakingData);
  bd->frosting = frosting;
  bd->message = g_strdup (message);
  g_task_set_task_data (task, bd, ( GDestroyNotify) baking_data_free);

  _baker_begin_cake (self, radius, flavor, cancellable, baked_cb, task);
}
```

```c
Cake * baker_bake_cake_finish (Baker *self, GAsyncResult *result, GError **error) {
  g_return_val_if_fail (g_task_is_valid (result, self), NULL);

  return g_task_propagate_pointer (G_TASK (result), error);
}
```

--------------------------------

### Setting up a source pad and pushing a buffer

Source: https://valadoc.org/gstreamer-check-1.0/Gst.Check.setup_src_pad_by_name.html

This example demonstrates how to set up a source pad using Gst.Check.setup_src_pad_by_name, configure it, and then push a buffer through it. Ensure to call setup_events on the created src pad before pushing data.

```c
static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",  
GST_PAD_SINK,  
GST_PAD_ALWAYS,  
GST_STATIC_CAPS (YOUR_CAPS_TEMPLATE_STRING)  
);  
static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",  
GST_PAD_SRC,  
GST_PAD_ALWAYS,  
GST_STATIC_CAPS (YOUR_CAPS_TEMPLATE_STRING)  
);  

GstElement * element = gst_check_setup_element ("element");  
GstPad * mysrcpad = gst_check_setup_src_pad (element, &srctemplate);  
GstPad * mysinkpad = gst_check_setup_sink_pad (element, &sinktemplate);  

gst_pad_set_active (mysrcpad, TRUE);  
gst_pad_set_active (mysinkpad, TRUE);  
fail_unless (gst_element_set_state (element, GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS, "could not set to playing");  

GstCaps * caps = gst_caps_from_string (YOUR_DESIRED_SINK_CAPS);  
gst_check_setup_events (mysrcpad, element, caps, GST_FORMAT_TIME);  
gst_caps_unref (caps);  

fail_unless (gst_pad_push (mysrcpad, gst_buffer_new_and_alloc(2)) == GST_FLOW_OK);
```

--------------------------------

### Get Start Point

Source: https://valadoc.org/gtk4/Gsk.LinearGradientNode.html

Retrieves the starting point of the linear gradient.

```APIDOC
## get_start()

### Description
Retrieves the initial point of the linear gradient.

### Returns
(Point?) The starting point of the gradient, or null if not set.
```

--------------------------------

### Create and run a SocketService

Source: https://valadoc.org/gio-2.0/GLib.SocketService.html

This example demonstrates how to create a SocketService, add TCP ports to listen on, connect to the 'incoming' signal to handle new connections, and start the service. The worker function processes incoming messages and sends a response. The server can be shut down by sending 'shutdown'.

```vala
public class Source : Object {
	public uint16 port { private set; get; }

	public Source (uint16 port) {
		this.port = port;
	}
}

public async void worker_func (SocketConnection connection, Source source, Cancellable cancellable) {
	try {
		DataInputStream istream = new DataInputStream (connection.input_stream);
		DataOutputStream ostream = new DataOutputStream (connection.output_stream);

		// Get the received message:
		string message = yield istream.read_line_async (Priority.DEFAULT, cancellable);
		message._strip ();
		print ("Received: %s\n", message);

		// Response:
		ostream.put_string (message, cancellable);
		ostream.put_byte ('\n', cancellable);

		if (message == "shutdown") {
			cancellable.cancel ();
		}
	} catch (Error e) {
		print ("Error: %s\n", e.message);
	}
}

public static int main (string[] args) {
	try {
		MainLoop loop = new MainLoop ();

		// Create a new SocketService:
		SocketService service = new SocketService ();

		// Listen on port 1024 and 1025.
		// Source is used as source-identifier.
		service.add_inet_port (1024, new Source (1024));
		service.add_inet_port (1025, new Source (1025));

		// Used to shutdown the program:
		Cancellable cancellable = new Cancellable ();
		cancellable.cancelled.connect (() => {
			service.stop ();
			loop.quit ();
		});

		service.incoming.connect ((connection, source_object) => {
			Source source = source_object as Source;

			print ("Accepted! (Source: %d)\n", source.port);
			worker_func.begin (connection, source, cancellable);
			return false;
		});

		service.start ();
		loop.run ();
	} catch (Error e) {
		print ("Error: %s\n", e.message);
	}
	return 0;
}
```

--------------------------------

### Get GUID

Source: https://valadoc.org/gio-2.0/GLib.DBusConnection.html

Retrieves the GUID of the peer acting as the server during authentication.

```APIDOC
## get_guid

### Description
The GUID of the peer performing the role of server when authenticating.

### Method
`public unowned string get_guid ()`
```

--------------------------------

### Initialize GStreamer and Play a Video

Source: https://valadoc.org/gstreamer-1.0/Gst.init.html

This example demonstrates how to initialize GStreamer, parse a launch string to create a pipeline, set it to playing, and wait for errors or the end of the stream. It also shows how to clean up resources by setting the pipeline state to NULL.

```vala
public static int main (string[] args) {
	// Initialize GStreamer:
	Gst.init (ref args);


	// Build the pipeline:
	Gst.Element pipeline;
	try {
		pipeline = Gst.parse_launch ("playbin uri=http://docs.gstreamer.com/media/sintel_trailer-480p.webm");
	} catch (Error e) {
		stderr.printf ("Error: %s\n", e.message);
		return 0;
	}

	// Start playing:
	pipeline.set_state (Gst.State.PLAYING);

	// Wait until error or EOS:
	Gst.Bus bus = pipeline.get_bus ();
	bus.timed_pop_filtered (Gst.CLOCK_TIME_NONE, Gst.MessageType.ERROR | Gst.MessageType.EOS);

	// Free resources:
	pipeline.set_state (Gst.State.NULL);

	return 0;
}
```

--------------------------------

### setup_with_main

Source: https://valadoc.org/dbus-glib-1/DBus.RawConnection.html

Sets up the connection to work with the GLib main loop.

```APIDOC
## setup_with_main

### Description
Configures the D-Bus connection to integrate with a GLib main loop. This allows the connection to process incoming messages and dispatch outgoing messages within the context of the main loop.

### Signature
public void setup_with_main (MainContext? context = null)

### Parameters
* **context** (MainContext?, optional) - The GLib MainContext to use. If null, the default main context is used.
```

--------------------------------

### Get Devices By GUID

Source: https://valadoc.org/fwupd/Fwupd.Client.html

Retrieves devices that provide a specific GUID.

```APIDOC
## Get Devices By GUID

### Methods:
  * public GenericArray<unowned Device> **get_devices_by_guid** (string guid, Cancellable? cancellable = null) throws Error
    Gets any devices that provide a specific GUID.
  * public async GenericArray<unowned Release> **get_devices_by_guid_async** (string guid, Cancellable? cancellable) throws Error
    Gets any devices that provide a specific GUID.
```

--------------------------------

### Get Start and Stop Times

Source: https://valadoc.org/gstreamer-1.0/Gst.TocEntry.html

Retrieves the start and stop times for the TocEntry.

```APIDOC
## Get Start and Stop Times

### Description
Gets the `start` and `stop` time values from this TocEntry.

### Signature
public bool **get_start_stop_times** (out int64 start, out int64 stop)
```

--------------------------------

### Resource Overlay Example

Source: https://valadoc.org/gio-2.0/GLib.Resource.html

This example demonstrates how to set up a resource overlay using the G_RESOURCE_OVERLAYS environment variable. The format specifies a resource subpath and a corresponding filesystem path for replacements.

```bash
export G_RESOURCE_OVERLAYS="/org/gtk/libgtk=/home/desrt/gtk-overlay"
```

--------------------------------

### Get Drag Start Point

Source: https://valadoc.org/gtk4/Gtk.GestureDrag.html

Retrieves the coordinates where the drag gesture initially started.

```APIDOC
## get_start_point

### Description
Gets the point where the drag started.

### Returns
`true` if the start point could be retrieved, `false` otherwise.

### Parameters
* **x** (double) - Output parameter for the x-coordinate of the start point.
* **y** (double) - Output parameter for the y-coordinate of the start point.
```

--------------------------------

### GStreamer Pipeline Example

Source: https://valadoc.org/gstreamer-1.0/Gst.StateChangeReturn.html

Demonstrates initializing GStreamer, creating elements, building a pipeline, setting its state to PLAYING, handling messages (ERROR or EOS), and cleaning up resources.

```vala
// See http://docs.gstreamer.com/x/ZgAF  
// for a detailed description  
  
public static int main (string[] args) {  
  
	// Initialize GStreamer:  
	Gst.init (ref args);  
  
	// Create the elements:  
	Gst.Element source = Gst.ElementFactory.make ("videotestsrc", "source");  
	Gst.Element sink = Gst.ElementFactory.make ("autovideosink", "sink");  
  
	// Create the empty pipeline:  
	Gst.Pipeline pipeline = new Gst.Pipeline ("test-pipeline");  
  
	if (source == null || sink == null || pipeline == null) {  
		stderr.puts ("Not all elements could be created.\n");  
		return -1;  
	}  
  
	// Build the pipeline:  
pipeline.add_many (source, sink);  
  
	if (source.link (sink) != true) {  
		stderr.puts ("Elements could not be linked.\n");  
		return -1;  
	}  
  
	// Modify the source's properties:  
source.set ("pattern", 0);  
  
	// Start playing:  
	Gst.StateChangeReturn ret = pipeline.set_state (Gst.State.PLAYING);  
	if (ret == Gst.StateChangeReturn.FAILURE) {  
		stderr.puts ("Unable to set the pipeline to the playing state.\n");  
		return -1;  
	}  
  
	// Wait until error or EOS:  
	Gst.Bus bus = pipeline.get_bus ();  
	Gst.Message msg = bus.timed_pop_filtered (Gst.CLOCK_TIME_NONE, Gst.MessageType.ERROR | Gst.MessageType.EOS);  
  
  
	// Parse message:  
	if (msg != null) {  
		switch (msg.type) {  
		case Gst.MessageType.ERROR:  
			GLib.Error err;  
			string debug_info;  
  
			msg.parse_error (out err, out debug_info);  
			stderr.printf ("Error received from element %s: %s\n", msg.src.name, err.message);  
			stderr.printf ("Debugging information: %s\n", (debug_info != null)? debug_info : "none");  
			break;  
  
		case Gst.MessageType.EOS:  
			print ("End-Of-Stream reached.\n");  
			break;  
  
		default:  
			// We should not reach here because we only asked for ERRORs and EOS:  
			assert_not_reached ();  
		}  
	}  
  
  
	// Free resources:  
pipeline.set_state (Gst.State.NULL);  
  
	return 0;  
}  

```

--------------------------------

### Gsk.Path.get_start_point

Source: https://valadoc.org/gtk4/Gsk.Path.html

Gets the start point of the path.

```APIDOC
## Gsk.Path.get_start_point

### Description
Gets the start point of the path.

### Method
`public unowned PathPoint get_start_point ()`

### Returns
The start point of the path.
```

--------------------------------

### GStreamer Hello World Example

Source: https://valadoc.org/gstreamer-1.0/Gst.Element.set_state.html

This example demonstrates initializing GStreamer, parsing a pipeline from a string, setting its state to PLAYING, waiting for errors or end-of-stream, and finally setting the state to NULL to free resources. It shows a common pattern for basic GStreamer applications.

```vala
// See http://docs.gstreamer.com/x/NwAF  
// for a detailed description  
  
public static int main (string[] args) {  
	// Initialize GStreamer:  
	Gst.init (ref args);  
  
  
	// Build the pipeline:  
	Gst.Element pipeline;  
	try {  
		pipeline = Gst.parse_launch ("playbin uri=http://docs.gstreamer.com/media/sintel_trailer-480p.webm");  
	} catch (Error e) {  
		stderr.printf ("Error: %s\n", e.message);  
		return 0;  
	}  
  
	// Start playing:  
	pipeline.set_state (Gst.State.PLAYING);  
  
	// Wait until error or EOS:  
	Gst.Bus bus = pipeline.get_bus ();  
	bus.timed_pop_filtered (Gst.CLOCK_TIME_NONE, Gst.MessageType.ERROR | Gst.MessageType.EOS);  
  
	// Free resources:  
	pipeline.set_state (Gst.State.NULL);  
  
	return 0;  
}
```

--------------------------------

### get_commandline

Source: https://valadoc.org/gio-2.0/GLib.AppInfo.html

Gets the commandline with which the application will be started.

```APIDOC
## get_commandline

### Description
Gets the commandline with which the application will be started.

### Method
`public abstract unowned string? get_commandline ()`
```

--------------------------------

### Example Application with File Handling

Source: https://valadoc.org/gio-2.0/GLib.Application.html

Demonstrates how to create a GLib.Application subclass that handles file opening requests. Use g_application_hold() and g_application_release() for longer-lasting actions.

```vala
public class MyApplication : Application {
	private MyApplication () {
		Object (application_id: "org.example.application", flags: ApplicationFlags.HANDLES_OPEN);
		set_inactivity_timeout (10000);
	}

	public override void activate () {
		// NOTE: when doing a longer-lasting action here that returns
		//  to the mainloop, you should use g_application_hold() and
		//  g_application_release() to keep the application alive until
		//  the action is completed.
	    print ("activated\n");
	}

	public override void open (File[] files, string hint) {
		// NOTE: when doing a longer-lasting action here that returns
		//  to the mainloop, you should use g_application_hold() and
		//  g_application_release() to keep the application alive until
		//  the action is completed.

		foreach (File file in files) {
			string uri = file.get_uri ();
			print (@"$uri\n");
		}
	}

	public static int main (string[] args) {
		MyApplication app = new MyApplication ();
		int status = app.run (args);
		return status;
	}
}
```

--------------------------------

### Setting up and Running a Clutter Test Suite

Source: https://valadoc.org/clutter-1.0/Clutter.test_run.html

This example demonstrates how to define test units, register them with clutter_test_add, and then run the entire test suite using clutter_test_run. Ensure clutter_test_init is called first.

```c
static void unit_foo (void) { ... }  
  
static void unit_bar (void) { ... }  
  
static void unit_baz (void) { ... }  
  
int  
main (int argc, char *argv[])  
{  
  clutter_test_init (&argc, &argv);  
  
  clutter_test_add ("/unit/foo", unit_foo);  
  clutter_test_add ("/unit/bar", unit_bar);  
  clutter_test_add ("/unit/baz", unit_baz);  
  
  return clutter_test_run ();  
}
```

--------------------------------

### get_name

Source: https://valadoc.org/gio-2.0/GLib.AppInfo.html

Gets the installed name of the application.

```APIDOC
## get_name

### Description
Gets the installed name of the application.

### Method
`public abstract unowned string get_name ()`
```

--------------------------------

### DiscovererInfo.get_missing_elements_installer_details

Source: https://valadoc.org/gstreamer-pbutils-1.0/Gst.PbUtils.DiscovererInfo.html

Get the installer details for missing elements.

```APIDOC
## DiscovererInfo.get_missing_elements_installer_details

### Description
Get the installer details for missing elements.

### Method
unowned string[] get_missing_elements_installer_details ()
```

--------------------------------

### get_description

Source: https://valadoc.org/gio-2.0/GLib.AppInfo.html

Gets a human-readable description of an installed application.

```APIDOC
## get_description

### Description
Gets a human-readable description of an installed application.

### Method
`public abstract unowned string? get_description ()`
```

--------------------------------

### AppLaunchContext Creation and Usage Example

Source: https://valadoc.org/gdk-3.0/Gdk.AppLaunchContext.html

Demonstrates how to create a GdkAppLaunchContext, set its properties like screen and timestamp, and then use it to launch a default application for a given URI.

```APIDOC
## Launching an application
```
GdkAppLaunchContext *context;

context = gdk_display_get_app_launch_context (display);

gdk_app_launch_context_set_screen (screen);
gdk_app_launch_context_set_timestamp (event->time);

if (!g_app_info_launch_default_for_uri ("http://www.gtk.org", context, &error))
  g_warning ("Launching failed: %s\n", error->message);

g_object_unref (context);
```
```

--------------------------------

### Compiling a Valadoc example

Source: https://valadoc.org/glib-2.0/GLib.PtrArray.html

Shows the command to compile a Valadoc example that uses GLib.PtrArray. Ensure the glib-2.0 package is installed and accessible.

```bash
valac --pkg glib-2.0 GLib.PtrArray.foreach.vala
```

--------------------------------

### GStreamer Hello World Example with CLOCK_TIME_NONE

Source: https://valadoc.org/gstreamer-1.0/Gst.CLOCK_TIME_NONE.html

This example demonstrates initializing GStreamer, building a simple playback pipeline, and waiting for an error or end-of-stream message using CLOCK_TIME_NONE for an indefinite wait. It shows the typical lifecycle of a GStreamer application.

```vala
// See http://docs.gstreamer.com/x/NwAF  
// for a detailed description  

public static int main (string[] args) {  
	// Initialize GStreamer:  
	Gst.init (ref args);  


	// Build the pipeline:  
	Gst.Element pipeline;
	try {  
		pipeline = Gst.parse_launch ("playbin uri=http://docs.gstreamer.com/media/sintel_trailer-480p.webm");  
	} catch (Error e) {  
		stderr.printf ("Error: %s\n", e.message);  
		return 0;  
	}  

	// Start playing:  
	pipeline.set_state (Gst.State.PLAYING);  

	// Wait until error or EOS:  
	Gst.Bus bus = pipeline.get_bus ();  

bus.timed_pop_filtered (Gst.CLOCK_TIME_NONE, Gst.MessageType.ERROR | Gst.MessageType.EOS);

	// Free resources:  
	pipeline.set_state (Gst.State.NULL);  

	return 0;
}

```

--------------------------------

### Source Pad Setup by Name from Template

Source: https://valadoc.org/gstreamer-check-1.0/index.htm

Sets up a source pad by name using a provided pad template.

```APIDOC
## setup_src_pad_by_name_from_template

### Description
Sets up a source pad by name using a provided pad template.

### Method
`public Pad setup_src_pad_by_name_from_template (Element element, PadTemplate tmpl, string name)`
```

--------------------------------

### Page Setup Properties

Source: https://valadoc.org/gtk4/Gtk.PageSetup.html

Methods for getting and setting various page setup properties like margins, orientation, and paper size.

```APIDOC
## Methods

### copy ()

Copies a `GtkPageSetup`.

### get_bottom_margin (Unit unit)

Gets the bottom margin in units of `unit`.

### get_left_margin (Unit unit)

Gets the left margin in units of `unit`.

### get_orientation ()

Gets the page orientation of the `GtkPageSetup`.

### get_page_height (Unit unit)

Returns the page height in units of `unit`.

### get_page_width (Unit unit)

Returns the page width in units of `unit`.

### get_paper_height (Unit unit)

Returns the paper height in units of `unit`.

### get_paper_size ()

Gets the paper size of the `GtkPageSetup`.

### get_paper_width (Unit unit)

Returns the paper width in units of `unit`.

### get_right_margin (Unit unit)

Gets the right margin in units of `unit`.

### get_top_margin (Unit unit)

Gets the top margin in units of `unit`.

### load_file (string file_name)

Reads the page setup from the file `file_name`.

### load_key_file (KeyFile key_file, string? group_name)

Reads the page setup from the group `group_name` in the key file `key_file`.

### set_bottom_margin (double margin, Unit unit)

Sets the bottom margin of the `GtkPageSetup`.

### set_left_margin (double margin, Unit unit)

Sets the left margin of the `GtkPageSetup`.

### set_orientation (PageOrientation orientation)

Sets the page orientation of the `GtkPageSetup`.

### set_paper_size (PaperSize size)

Sets the paper size of the `GtkPageSetup` without changing the margins.

### set_paper_size_and_default_margins (PaperSize size)

Sets the paper size of the `GtkPageSetup` and modifies the margins according to the new paper size.

### set_right_margin (double margin, Unit unit)

Sets the right margin of the `GtkPageSetup`.

### set_top_margin (double margin, Unit unit)

Sets the top margin of the `GtkPageSetup`.

### to_file (string file_name)

This function saves the information from this to `file_name`.

### to_gvariant ()

Serialize page setup to an a{sv} variant.

### to_key_file (KeyFile key_file, string? group_name)

This function adds the page setup from this to `key_file`.
```

--------------------------------

### TimelineElement.start

Source: https://valadoc.org/gst-editing-services-1.0/GES.TimelineElement.start.html

Gets or sets the starting position of the element in the timeline (in nanoseconds and in the time coordinates of the timeline). This determines when a source element starts outputting its content or when an operation element starts applying its effect.

```APIDOC
## TimelineElement.start

### Description
Gets or sets the starting position of the element in the timeline (in nanoseconds and in the time coordinates of the timeline).
For example, for a source element, this would determine the time at which it should start outputting its internal content. For an operation element, this would determine the time at which it should start applying its effect to any source content.

### Property
`public uint64 start { get; set; }`
```

--------------------------------

### Creating and Using Simple Actions in an Application

Source: https://valadoc.org/gio-2.0/GLib.SimpleAction.html

This example demonstrates how to create a Gio.Application and add both simple and stateful actions to it. It shows how to connect to the activate signal and manage the state of a stateful action.

```vala
public class MyApplication : Application {
	private MyApplication () {
		Object (application_id: "org.example.application", flags: 0);
		set_inactivity_timeout (10000);
		add_actions ();
	}
  
	private void add_actions () {
		SimpleAction simple_action = new SimpleAction ("simple-action", null);
		simple_action.activate.connect (() => {
			this.hold ();
			print ("Simple action %s activated\n", simple_action.get_name ());
			this.release ();
		});
		this.add_action (simple_action);
  
		SimpleAction stateful_action = new SimpleAction.stateful ("toggle-action", null, new Variant.boolean (false));
		stateful_action.activate.connect (() => {
			print ("Action %s activated\n", stateful_action.get_name ());

			this.hold ();
			Variant state = stateful_action.get_state ();
			bool b = state.get_boolean ();
			stateful_action.set_state (new Variant.boolean (!b));
			print (@"State change $b -> $(!b)\n");
			this.release ();
		});
		this.add_action (stateful_action);
	}
  
	public override void activate () {
		this.hold ();
		print ("Activated\n");
		this.release ();
	}
  
	private void describe_and_activate_action (string name) {
		VariantType param_type = this.get_action_parameter_type (name);
		Variant state = this.get_action_state (name);
		bool enabled = this.get_action_enabled (name);

		print (@"Action name:      $name\n");
		string? type = (param_type != null) ? param_type.dup_string () : "<none>";
		print (@"Parameter type:   $type\n");

		print ("State type:       %s\n", (state != null) ? state.get_type_string () : "<none>");
		string state_val = (state != null) ? state.print (false) : "<none>";
		print (@"State:            $state_val\n");
		print (@"Enabled:          $enabled\n");

		this.activate_action (name, null);
	}
  
	public static int main (string[] args) {
		try {
			MyApplication app = new MyApplication ();

			if (args.length > 1) {
				if (args[1] == "--simple-action") {
					app.register (null);
					app.describe_and_activate_action ("simple-action");
					Process.exit (0);
				} else if (args[1] == "--toggle-action") {
					app.register (null);
					app.describe_and_activate_action ("toggle-action");
					Process.exit (0);
				}
			}

			int status = app.run (args);
			return status;
		} catch (Error e) {
			print ("Error: %s\n", e.message);
			return 0;
		}
	}
}
```

--------------------------------

### GStreamer Pipeline Example with Message Handling

Source: https://valadoc.org/gstreamer-1.0/Gst.MessageType.html

This example demonstrates initializing GStreamer, creating a simple video pipeline, setting its state to playing, and then waiting for and processing error or end-of-stream messages from the pipeline's bus. It covers basic pipeline construction and message parsing.

```vala
// See http://docs.gstreamer.com/x/ZgAF  
// for a detailed description  

public static int main (string[] args) {

	// Initialize GStreamer:  
	Gst.init (ref args);

	// Create the elements:  
	Gst.Element source = Gst.ElementFactory.make ("videotestsrc", "source");  
	Gst.Element sink = Gst.ElementFactory.make ("autovideosink", "sink");  

	// Create the empty pipeline:  
	Gst.Pipeline pipeline = new Gst.Pipeline ("test-pipeline");  

	if (source == null || sink == null || pipeline == null) {
		stderr.puts ("Not all elements could be created.\n");  
		return -1;
	}

	// Build the pipeline:  

pipeline.add_many (source, sink);

	if (source.link (sink) != true) {
		stderr.puts ("Elements could not be linked.\n");  
		return -1;
	}

	// Modify the source's properties:  

source.set ("pattern", 0);

	// Start playing:  
	Gst.StateChangeReturn ret = pipeline.set_state (Gst.State.PLAYING);  
	if (ret == Gst.StateChangeReturn.FAILURE) {
		stderr.puts ("Unable to set the pipeline to the playing state.\n");  
		return -1;
	}

	// Wait until error or EOS:  
	Gst.Bus bus = pipeline.get_bus ();  
	Gst.Message msg = bus.timed_pop_filtered (Gst.CLOCK_TIME_NONE, Gst.MessageType.ERROR | Gst.MessageType.EOS);


	// Parse message:  
	if (msg != null) {
		switch (msg.type) {
		case Gst.MessageType.ERROR:
			GLib.Error err;
			string debug_info;

			msg.parse_error (out err, out debug_info);
			stderr.printf ("Error received from element %s: %s\n", msg.src.name, err.message);
			stderr.printf ("Debugging information: %s\n", (debug_info != null)? debug_info : "none");
			break;

		case Gst.MessageType.EOS:
			print ("End-Of-Stream reached.\n");
			break;

		default:
			// We should not reach here because we only asked for ERRORs and EOS:
			assert_not_reached ();
		}
	}


	// Free resources:  

pipeline.set_state (Gst.State.NULL);

	return 0;
}

```

--------------------------------

### get_executable

Source: https://valadoc.org/gio-2.0/GLib.AppInfo.html

Gets the executable’s name for the installed application.

```APIDOC
## get_executable

### Description
Gets the executable’s name for the installed application.

### Method
`public abstract unowned string get_executable ()`
```

--------------------------------

### get_line_at_y

Source: https://valadoc.org/gtk4/Gtk.TextView.html

Gets the GtkTextIter at the start of the line containing the coordinate y.

```APIDOC
## get_line_at_y

### Description
Gets the GtkTextIter at the start of the line containing the coordinate y.

### Parameters
* **target_iter** (out TextIter) - Output parameter for the text iterator at the start of the line.
* **y** (int) - The y-coordinate.
* **line_top** (out int) - Output parameter for the y-coordinate of the top of the line.

### Returns
void
```

--------------------------------

### GtkApplicationWindow with Menubar Setup

Source: https://valadoc.org/gtk4/Gtk.ApplicationWindow.html

Demonstrates how to create a GtkApplicationWindow and associate a menubar defined in Gtk.Application. Requires GTK+ and GObject introspection.

```c
GtkApplication *app = gtk_application_new ("org.gtk.test", 0);
GtkBuilder *builder = gtk_builder_new_from_string ( "<interface>" " <menu id='menubar'>" " <submenu>" " <attribute name='label' translatable='yes'>_Edit</attribute>" " <item>" " <attribute name='label' translatable='yes'>_Copy< /attribute>" " <attribute name='action'>win.copy</attribute>" " </item>" " <item>" " <attribute name='label' translatable='yes'>_Paste</attribute>" " <attribute name='action'>win.paste</attribute>" " </item>" " </submenu >" " </menu>""</interface>", -1);
GMenuModel *menubar = G_MENU_MODEL (gtk_builder_get_object (builder, "menubar")); gtk_application_set_menubar (GTK_APPLICATION (app), menubar);
g_object_unref (builder);
// ...
GtkWidget *window = gtk_application_window_new (app);
```

--------------------------------

### Run All Tests

Source: https://valadoc.org/glib-2.0/GLib.Test.run.html

This example demonstrates how to initialize GLib.Test, add several test functions, and then run all of them using Test.run().

```vala
public static int main (string[] args) {
	Test.init (ref args);

	// Add some random test cases:
	Test.add_func ("/libvaladoc/driver-0.12.x", () => {
		// TODO: test
		Test.fail ();
	});
	Test.add_func ("/libvaladoc/driver-0.12.x", () => {
		// TODO: test
	});
	Test.add_func ("/libvaladoc/driver-0.12.x", () => {
		// TODO: test
	});

	// Run all tests!
	return Test.run ();
}
```

--------------------------------

### get_embed_page_setup

Source: https://valadoc.org/gtk4/Gtk.PrintOperation.html

Gets whether page setup selection combos are embedded.

```APIDOC
## get_embed_page_setup

### Description
Gets whether page setup selection combos are embedded.

### Method
`bool get_embed_page_setup()`
```
Tokens:
Raw