#define BACKEND_NAME "ALSA"

#define BACKEND_PRIORITY 20

#define ALSA_DEVICE_GET_ID(d) \

(g_object_get_data (G_OBJECT (d), "__matemixer_alsa_device_id"))

{

alsa_backend_register_type (module);

}

const MateMixerBackendInfo *backend_module_get_info (void)

static void

add_device (AlsaBackend *alsa, AlsaDevice *device)

{

/* Keep track of device identifiers */

g_hash_table_add (alsa->priv->devices_ids, g_strdup (ALSA_DEVICE_GET_ID (device)));

close_mixer (device);

}

AlsaDevice *

for (i = 0; i < control->priv->data.channels; i++)

control->priv->data.m[i] = mute;

}

return TRUE;

}

"label", label,

"flags", MATE_MIXER_SWITCH_TOGGLE,

"role", role,

NULL);

toggle->priv->type = type;

#define BACKEND_NAME "Null"

#define BACKEND_PRIORITY 0

static void null_backend_class_init (NullBackendClass *klass);

static void null_backend_class_finalize (NullBackendClass *klass);

{

null_backend_register_type (module);

}

const MateMixerBackendInfo *backend_module_get_info (void)

#define BACKEND_NAME "OSS"

#define BACKEND_PRIORITY 10

#if !defined(__linux__) && !defined(__NetBSD__) && !defined(__OpenBSD__)

/* At least on systems based on FreeBSD we will need to read device names

{

oss_backend_register_type (module);

}

const MateMixerBackendInfo *backend_module_get_info (void)

static void

add_device (OssBackend *oss, OssDevice *device)

{

oss->priv->devices =

g_list_insert_sorted_with_data (oss->priv->devices,

device,

#define BACKEND_NAME "PulseAudio"

#define BACKEND_PRIORITY 100

struct _PulseBackendPrivate

{

NULL))

#define PULSE_GET_HANGING(o) \

#define PULSE_SET_HANGING(o) \

(g_object_set_data (G_OBJECT (o), \

{

pulse_backend_register_type (module);

}

const MateMixerBackendInfo *backend_module_get_info (void)

return FALSE;

}

pulse->priv->connection = connection;

return TRUE;

}

g_hash_table_insert (pulse->priv->devices,

GUINT_TO_POINTER (info->index),

free_list_devices (pulse);

g_signal_emit_by_name (G_OBJECT (pulse),

free_list_streams (pulse);

g_hash_table_insert (pulse->priv->sinks,

GUINT_TO_POINTER (info->index),

if (device != NULL) {

pulse_device_add_stream (device, stream);

free_list_streams (pulse);

g_hash_table_insert (pulse->priv->sources,

GUINT_TO_POINTER (info->index),

if (device != NULL) {

pulse_device_add_stream (device, stream);

free_list_ext_streams (pulse);

g_hash_table_insert (pulse->priv->ext_streams,

g_strdup (info->name),

g_signal_emit_by_name (G_OBJECT (pulse),

"stored-control-added",

continue;

free_list_ext_streams (pulse);

g_signal_emit_by_name (G_OBJECT (pulse),

"stored-control-removed",

free_list_streams (device);

g_signal_emit_by_name (G_OBJECT (device),

"stream-added",

name);

icon,

info->ports[i]->priority);

}

#endif

struct _PulseExtStreamPrivate

{

};

enum {

PROP_0,

};

static void pulse_ext_stream_class_init (PulseExtStreamClass *klass);

GParamSpec *pspec);

static void pulse_ext_stream_init (PulseExtStream *ext);

static void

pulse_ext_stream_class_init (PulseExtStreamClass *klass)

{

GObjectClass *object_class;

MateMixerStreamControlClass *control_class;

object_class = G_OBJECT_CLASS (klass);

object_class->get_property = pulse_ext_stream_get_property;

object_class->set_property = pulse_ext_stream_set_property;

control_class = MATE_MIXER_STREAM_CONTROL_CLASS (klass);

g_type_class_add_private (object_class, sizeof (PulseExtStreamPrivate));

}

ext = PULSE_EXT_STREAM (object);

switch (param_id) {

break;

default:

G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);

ext = PULSE_EXT_STREAM (object);

switch (param_id) {

break;

default:

G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);

PulseExtStreamPrivate);

}

PulseExtStream *

pulse_ext_stream_new (PulseConnection *connection,

const pa_ext_stream_restore_info *info,

PulseStream *parent)

{

g_return_val_if_fail (PULSE_IS_CONNECTION (connection), NULL);

g_return_val_if_fail (info != NULL, NULL);

if (g_str_has_prefix (info->name, "sink-input"))

direction = MATE_MIXER_DIRECTION_OUTPUT;

else if (g_str_has_prefix (info->name, "source-output"))

else

direction = MATE_MIXER_DIRECTION_UNKNOWN;

suffix = strchr (info->name, ':');

if (suffix != NULL)

suffix++;

if (strstr (info->name, "-by-media-role:")) {

media_role = pulse_convert_media_role_name (suffix);

}

else if (strstr (info->name, "-by-application-name:")) {

role = MATE_MIXER_STREAM_CONTROL_ROLE_APPLICATION;

_mate_mixer_app_info_set_name (app_info, suffix);

}

else if (strstr (info->name, "-by-application-id:")) {

role = MATE_MIXER_STREAM_CONTROL_ROLE_APPLICATION;

_mate_mixer_app_info_set_id (app_info, suffix);

}

"stream", parent,

NULL);

pulse_ext_stream_update (ext, info, parent);

return ext;

}

const pa_ext_stream_restore_info *info,

PulseStream *parent)

{

g_return_if_fail (PULSE_IS_EXT_STREAM (ext));

g_return_if_fail (info != NULL);

_mate_mixer_stream_control_set_mute (MATE_MIXER_STREAM_CONTROL (ext),

info->mute ? TRUE : FALSE);

_mate_mixer_stream_control_set_stream (MATE_MIXER_STREAM_CONTROL (ext),

MATE_MIXER_STREAM (parent));

g_object_thaw_notify (G_OBJECT (ext));

}

static MateMixerAppInfo *

pulse_ext_stream_get_app_info (MateMixerStreamControl *mmsc)

{

static gboolean

pulse_ext_stream_set_stream (MateMixerStreamControl *mmsc, MateMixerStream *mms)

{

pa_ext_stream_restore_info info;

g_return_val_if_fail (PULSE_IS_EXT_STREAM (mmsc), FALSE);

g_return_val_if_fail (mms == NULL || PULSE_IS_STREAM (mms), FALSE);

if (mms != NULL)

info.device = mate_mixer_stream_get_name (mms);

else

info.device = NULL;

}

static gboolean

{

pa_ext_stream_restore_info info;

info.mute = mute;

}

static gboolean

{

}

static void

pa_ext_stream_restore_info *info)

{

MateMixerStreamControl *mmsc;

info->name = mate_mixer_stream_control_get_name (mmsc);

info->mute = mate_mixer_stream_control_get_mute (mmsc);

else

info->device = NULL;

}

struct _PulseExtStream

{

/*< private >*/

PulseExtStreamPrivate *priv;

struct _PulseExtStreamClass

{

};

GType pulse_ext_stream_get_type (void) G_GNUC_CONST;

GParamSpec *pspec);

static void pulse_port_switch_init (PulsePortSwitch *swtch);

G_DEFINE_ABSTRACT_TYPE (PulsePortSwitch, pulse_port_switch, MATE_MIXER_TYPE_SWITCH)

MateMixerSwitchClass *switch_class;

object_class = G_OBJECT_CLASS (klass);

object_class->get_property = pulse_port_switch_get_property;

object_class->set_property = pulse_port_switch_set_property;

switch (param_id) {

case PROP_STREAM:

/* Construct-only object */

break;

default:

G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);

PulsePortSwitchPrivate);

}

PulseStream *

pulse_port_switch_get_stream (PulsePortSwitch *swtch)

{

input = pulse_sink_input_new (sink, info);

g_hash_table_insert (sink->priv->inputs,

GINT_TO_POINTER (info->index),

name = mate_mixer_stream_control_get_name (MATE_MIXER_STREAM_CONTROL (input));

g_signal_emit_by_name (G_OBJECT (sink),

output = pulse_source_output_new (source, info);

g_hash_table_insert (source->priv->outputs,

GINT_TO_POINTER (info->index),

name = mate_mixer_stream_control_get_name (MATE_MIXER_STREAM_CONTROL (output));

g_signal_emit_by_name (G_OBJECT (source),

if (channel >= control->priv->channel_map.channels)

return MATE_MIXER_CHANNEL_UNKNOWN;

}

static gboolean

static void

pulse_stream_class_init (PulseStreamClass *klass)

{

object_class = G_OBJECT_CLASS (klass);

object_class->dispose = pulse_stream_dispose;

object_class->get_property = pulse_stream_get_property;

object_class->set_property = pulse_stream_set_property;

properties[PROP_INDEX] =

g_param_spec_uint ("index",

"Index",

# Header files or dirs to ignore when scanning. Use base file/dir names

# e.g. IGNORE_HFILES=gtkdebug.h gtkintl.h private_code

IGNORE_HFILES= \

matemixer-backend.h \

matemixer-backend-module.h \

matemixer-enum-types.h \

matemixer-private.h

# Images to copy into HTML directory.

<chapter>

<title>API Reference</title>

<xi:include href="xml/matemixer.xml"/>

<xi:include href="xml/matemixer-device.xml"/>

<xi:include href="xml/matemixer-stream.xml"/>

</chapter>

<index id="api-index-full">

<title>API Index</title>

<SECTION>

<FILE>matemixer</FILE>

mate_mixer_init

mate_mixer_is_initialized

LIBMATEMIXER_CHECK_VERSION

</SECTION>

<SECTION>

<SUBSECTION Standard>

</SECTION>

<SECTION>

MateMixerState

MateMixerBackendType

<SUBSECTION Standard>

<SUBSECTION Private>

</SECTION>

<SECTION>

<FILE>matemixer-device</FILE>

<TITLE>MateMixerDevice</TITLE>

MateMixerDevice

mate_mixer_device_get_name

mate_mixer_device_get_icon

<SUBSECTION Standard>

MATE_MIXER_DEVICE

MATE_MIXER_IS_DEVICE

MATE_MIXER_TYPE_DEVICE

<SUBSECTION Private>

</SECTION>

<SECTION>

<SUBSECTION Standard>

<SUBSECTION Private>

</SECTION>

<SECTION>

<FILE>matemixer-stream</FILE>

<TITLE>MateMixerStream</TITLE>

MateMixerStream

mate_mixer_stream_get_name

mate_mixer_stream_get_device

<SUBSECTION Standard>

MATE_MIXER_IS_STREAM

MATE_MIXER_STREAM

MATE_MIXER_TYPE_STREAM

mate_mixer_stream_get_type

</SECTION>

#include "matemixer-app-info.h"

#include "matemixer-app-info-private.h"

G_DEFINE_BOXED_TYPE (MateMixerAppInfo, mate_mixer_app_info,

_mate_mixer_app_info_copy,

_mate_mixer_app_info_free)

/**

* mate_mixer_app_info_get_name:

*/

const gchar *

mate_mixer_app_info_get_name (MateMixerAppInfo *info)

/**

* mate_mixer_app_info_get_id:

*/

const gchar *

mate_mixer_app_info_get_id (MateMixerAppInfo *info)

/**

* mate_mixer_app_info_get_version:

*/

const gchar *

mate_mixer_app_info_get_version (MateMixerAppInfo *info)

/**

* mate_mixer_app_info_get_icon:

*/

const gchar *

mate_mixer_app_info_get_icon (MateMixerAppInfo *info)

return info->icon;

}

MateMixerAppInfo *

_mate_mixer_app_info_new (void)

{

return g_slice_new0 (MateMixerAppInfo);

}

void

_mate_mixer_app_info_set_name (MateMixerAppInfo *info, const gchar *name)

{

info->name = g_strdup (name);

}

void

_mate_mixer_app_info_set_id (MateMixerAppInfo *info, const gchar *id)

{

info->id = g_strdup (id);

}

void

_mate_mixer_app_info_set_version (MateMixerAppInfo *info, const gchar *version)

{

info->version = g_strdup (version);

}

void

_mate_mixer_app_info_set_icon (MateMixerAppInfo *info, const gchar *icon)

{

info->icon = g_strdup (icon);

}

MateMixerAppInfo *

_mate_mixer_app_info_copy (MateMixerAppInfo *info)

{

MateMixerAppInfo *info2;

info2 = _mate_mixer_app_info_new ();

info2->name = g_strdup (info->name);

info2->id = g_strdup (info->id);

return info2;

}

void

_mate_mixer_app_info_free (MateMixerAppInfo *info)

{

g_free (info->name);

g_free (info->id);

g_free (info->version);

G_BEGIN_DECLS

#define MATE_MIXER_TYPE_APP_INFO (mate_mixer_app_info_get_type ())

GType mate_mixer_app_info_get_type (void) G_GNUC_CONST;

switch (param_id) {

case PROP_PATH:

/* Construct-only string */

g_type_module_set_name (G_TYPE_MODULE (object), module->priv->path);

break;

*

* Gets file path to the backend module.

*

*/

const gchar *

mate_mixer_backend_module_get_path (MateMixerBackendModule *module)

return TRUE;

module->priv->gmodule = g_module_open (module->priv->path,

if (module->priv->gmodule == NULL) {

g_warning ("Failed to load backend module %s: %s",

module->priv->path,

/* Make sure get_info() returns something, so we can avoid checking it

* in other parts of the library */

g_critical ("Backend module %s does not provide module information",

module->priv->path);

gchar *name;

guint priority;

GType g_type;

MateMixerBackendType backend_type;

};

return backend->priv->state;

}

MateMixerDevice *

mate_mixer_backend_get_device (MateMixerBackend *backend, const gchar *name)

{

klass = MATE_MIXER_BACKEND_GET_CLASS (backend);

return klass->list_devices (backend);

return NULL;

klass = MATE_MIXER_BACKEND_GET_CLASS (backend);

return klass->list_streams (backend);

return NULL;

mate_mixer_backend_set_default_input_stream (MateMixerBackend *backend,

MateMixerStream *stream)

{

g_return_val_if_fail (MATE_MIXER_IS_BACKEND (backend), FALSE);

g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), FALSE);

return FALSE;

_mate_mixer_backend_set_default_input_stream (backend, stream);

}

return TRUE;

}

mate_mixer_backend_set_default_output_stream (MateMixerBackend *backend,

MateMixerStream *stream)

{

g_return_val_if_fail (MATE_MIXER_IS_BACKEND (backend), FALSE);

g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), FALSE);

return FALSE;

_mate_mixer_backend_set_default_output_stream (backend, stream);

}

return TRUE;

}

}

void

_mate_mixer_backend_set_default_input_stream (MateMixerBackend *backend,

MateMixerStream *stream)

{

GType mate_mixer_backend_get_type (void) G_GNUC_CONST;

/* Protected functions */

G_END_DECLS

* License along with this library; if not, see <http://www.gnu.org/licenses/>.

*/

#include <glib.h>

#include <glib-object.h>

* SECTION:matemixer-context

* @short_description:The main class for interfacing with the library

* @include: libmatemixer/matemixer.h

*/

struct _MateMixerContextPrivate

/**

* MateMixerContext:app-icon:

*

*/

properties[PROP_APP_ICON] =

g_param_spec_string ("app-icon",

"App icon",

NULL,

G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);

*

* Address of the sound server to connect to.

*

*/

properties[PROP_SERVER_ADDRESS] =

g_param_spec_string ("server-address",

NULL,

G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);

properties[PROP_STATE] =

g_param_spec_enum ("state",

"State",

MATE_MIXER_STATE_IDLE,

G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);

properties[PROP_DEFAULT_INPUT_STREAM] =

g_param_spec_object ("default-input-stream",

"Default input stream",

MATE_MIXER_TYPE_STREAM,

G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);

properties[PROP_DEFAULT_OUTPUT_STREAM] =

g_param_spec_object ("default-output-stream",

"Default output stream",

* @name: name of the added device

*

* The signal is emitted each time a device is added to the system.

*/

signals[DEVICE_ADDED] =

g_signal_new ("device-added",

G_TYPE_FROM_CLASS (object_class),

G_STRUCT_OFFSET (MateMixerContextClass, device_added),

NULL,

NULL,

* @name: name of the removed device

*

* The signal is emitted each time a device is removed from the system.

*/

signals[DEVICE_REMOVED] =

g_signal_new ("device-removed",

G_TYPE_FROM_CLASS (object_class),

G_STRUCT_OFFSET (MateMixerContextClass, device_removed),

NULL,

NULL,

* @context: a #MateMixerContext

* @name: name of the added stream

*

*/

signals[STREAM_ADDED] =

g_signal_new ("stream-added",

G_TYPE_FROM_CLASS (object_class),

G_STRUCT_OFFSET (MateMixerContextClass, stream_added),

NULL,

NULL,

* @name: name of the removed stream

*

* The signal is emitted each time a stream is removed.

*/

signals[STREAM_REMOVED] =

g_signal_new ("stream-removed",

G_TYPE_FROM_CLASS (object_class),

G_STRUCT_OFFSET (MateMixerContextClass, stream_removed),

NULL,

NULL,

* @context: a #MateMixerContext

* @name: name of the added stored control

*

*/

signals[STORED_CONTROL_ADDED] =

g_signal_new ("stored-control-added",

G_TYPE_FROM_CLASS (object_class),

G_STRUCT_OFFSET (MateMixerContextClass, stored_control_added),

NULL,

NULL,

/**

* MateMixerContext::stored-control-removed:

* @context: a #MateMixerContext

*

*/

signals[STORED_CONTROL_REMOVED] =

g_signal_new ("stored-control-removed",

G_TYPE_FROM_CLASS (object_class),

G_STRUCT_OFFSET (MateMixerContextClass, stored_control_removed),

NULL,

NULL,

* Creates a new #MateMixerContext instance.

*

* Returns: a new #MateMixerContext instance or %NULL if the library has not

*/

MateMixerContext *

mate_mixer_context_new (void)

* Makes the #MateMixerContext use the given #MateMixerBackendType.

*

* By default the backend type is determined automatically. This function can

*

*

* Returns: %TRUE on success or %FALSE on failure.

*/

gboolean

{

MateMixerBackendModule *module;

const GList *modules;

context->priv->state == MATE_MIXER_STATE_READY)

return FALSE;

while (modules != NULL) {

module = MATE_MIXER_BACKEND_MODULE (modules->data);

info = mate_mixer_backend_module_get_info (module);

* @context: a #MateMixerContext

* @app_name: the name of your application, or %NULL to unset

*

*

*

* Returns: %TRUE on success or %FALSE on failure.

*/

_mate_mixer_app_info_set_name (context->priv->app_info, app_name);

return TRUE;

}

* @context: a #MateMixerContext

* @app_id: the identifier of your application, or %NULL to unset

*

*

*

* Returns: %TRUE on success or %FALSE on failure.

*/

_mate_mixer_app_info_set_id (context->priv->app_info, app_id);

return TRUE;

}

* @context: a #MateMixerContext

* @app_version: the version of your application, or %NULL to unset

*

*

*

* Returns: %TRUE on success or %FALSE on failure.

*/

_mate_mixer_app_info_set_version (context->priv->app_info, app_version);

return TRUE;

}

* @context: a #MateMixerContext

* @app_icon: the XDG icon name of your application, or %NULL to unset

*

*

*

* Returns: %TRUE on success or %FALSE on failure.

*/

_mate_mixer_app_info_set_icon (context->priv->app_info, app_icon);

return TRUE;

}

* PulseAudio backend. If the address is not set, the default PulseAudio sound

* server will be used, which is normally the local daemon.

*

*

* Returns: %TRUE on success or %FALSE on failure.

*/

context->priv->server_address = g_strdup (address);

return TRUE;

}

* mate_mixer_context_open:

* @context: a #MateMixerContext

*

*

* This function can complete the operation either synchronously or

*

*

*

* Returns: %TRUE on success or if the result will be determined asynchronously,

* or %FALSE on failure.

return FALSE;

/* We are going to choose the first backend to try. It will be either the one

modules = _mate_mixer_list_modules ();

if (context->priv->backend_type != MATE_MIXER_BACKEND_UNKNOWN) {

state = mate_mixer_backend_get_state (context->priv->backend);

/* This would be a backend bug */

g_warn_if_reached ();

* mate_mixer_context_close:

* @context: a #MateMixerContext

*

*/

void

mate_mixer_context_close (MateMixerContext *context)

* mate_mixer_context_get_state:

* @context: a #MateMixerContext

*

*

*/

MateMixerState

mate_mixer_context_get_state (MateMixerContext *context)

*

* Gets the stored control with the given name.

*

*/

MateMixerStoredControl *

mate_mixer_context_get_stored_control (MateMixerContext *context, const gchar *name)

* mate_mixer_context_list_devices:

* @context: a #MateMixerContext

*

*

*

* Returns: a #GList of all devices in the system or %NULL if there are none or

* you are not connected to a sound system.

* mate_mixer_context_list_streams:

* @context: a #MateMixerContext

*

*

*

* Returns: a #GList of all streams in the system or %NULL if there are none or

* you are not connected to a sound system.

* mate_mixer_context_list_stored_controls:

* @context: a #MateMixerContext

*

*/

const GList *

mate_mixer_context_list_stored_controls (MateMixerContext *context)

* mate_mixer_context_get_default_input_stream:

* @context: a #MateMixerContext

*

*

*/

MateMixerStream *

mate_mixer_context_get_default_input_stream (MateMixerContext *context)

* @context: a #MateMixerContext

* @stream: a #MateMixerStream to set as the default input stream

*

*

* Returns: %TRUE on success or %FALSE on failure.

*/

if (context->priv->state != MATE_MIXER_STATE_READY)

return FALSE;

return mate_mixer_backend_set_default_input_stream (context->priv->backend, stream);

}

* @context: a #MateMixerContext

*

* Gets the default output stream. The returned stream is where sound output is

*

* Returns: a #MateMixerStream or %NULL if there are no output streams in

* the system.

* @context: a #MateMixerContext

* @stream: a #MateMixerStream to set as the default output stream

*

*

* Returns: %TRUE on success or %FALSE on failure.

*/

if (context->priv->state != MATE_MIXER_STATE_READY)

return FALSE;

return mate_mixer_backend_set_default_output_stream (context->priv->backend, stream);

}

* mate_mixer_context_get_backend_name:

* @context: a #MateMixerContext

*

*

* Returns: the name or %NULL on error.

*/

* mate_mixer_context_get_backend_type:

* @context: a #MateMixerContext

*

*

* Returns: the backend type or %MATE_MIXER_BACKEND_UNKNOWN on error.

*/

/**

* mate_mixer_context_get_backend_flags:

* @context: a #MateMixerContext

*/

MateMixerBackendFlags

mate_mixer_context_get_backend_flags (MateMixerContext *context)

{

g_return_val_if_fail (MATE_MIXER_IS_CONTEXT (context), MATE_MIXER_BACKEND_NO_FLAGS);

}

static void

state = mate_mixer_backend_get_state (context->priv->backend);

/* This would be a backend bug */

g_warn_if_reached ();

/**

* MateMixerContextClass:

*

*/

struct _MateMixerContextClass

{

* SECTION:matemixer-device

* @short_description: Hardware or software device in the sound system

* @include: libmatemixer/matemixer.h

*/

struct _MateMixerDevicePrivate

G_DEFINE_ABSTRACT_TYPE (MateMixerDevice, mate_mixer_device, G_TYPE_OBJECT)

static void

mate_mixer_device_class_init (MateMixerDeviceClass *klass)

{

GObjectClass *object_class;

object_class = G_OBJECT_CLASS (klass);

object_class->finalize = mate_mixer_device_finalize;

object_class->get_property = mate_mixer_device_get_property;

object_class->set_property = mate_mixer_device_set_property;

properties[PROP_NAME] =

g_param_spec_string ("name",

"Name",

G_PARAM_CONSTRUCT_ONLY |

G_PARAM_STATIC_STRINGS);

properties[PROP_LABEL] =

g_param_spec_string ("label",

"Label",

G_PARAM_CONSTRUCT_ONLY |

G_PARAM_STATIC_STRINGS);

properties[PROP_ICON] =

g_param_spec_string ("icon",

"Icon",

NULL,

G_PARAM_READWRITE |

G_PARAM_CONSTRUCT_ONLY |

g_object_class_install_properties (object_class, N_PROPERTIES, properties);

signals[STREAM_ADDED] =

g_signal_new ("stream-added",

G_TYPE_FROM_CLASS (object_class),

G_STRUCT_OFFSET (MateMixerDeviceClass, stream_added),

NULL,

NULL,

1,

G_TYPE_STRING);

signals[STREAM_REMOVED] =

g_signal_new ("stream-removed",

G_TYPE_FROM_CLASS (object_class),

G_STRUCT_OFFSET (MateMixerDeviceClass, stream_removed),

NULL,

NULL,

1,

G_TYPE_STRING);

signals[SWITCH_ADDED] =

g_signal_new ("switch-added",

G_TYPE_FROM_CLASS (object_class),

G_STRUCT_OFFSET (MateMixerDeviceClass, switch_added),

NULL,

NULL,

1,

G_TYPE_STRING);

signals[SWITCH_REMOVED] =

g_signal_new ("switch-removed",

G_TYPE_FROM_CLASS (object_class),

G_STRUCT_OFFSET (MateMixerDeviceClass, switch_removed),

NULL,

NULL,

case PROP_ICON:

g_value_set_string (value, device->priv->icon);

break;

default:

G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);

break;

switch (param_id) {

case PROP_NAME:

/* Construct-only string */

break;

case PROP_LABEL:

/* Construct-only string */

break;

case PROP_ICON:

/* Construct-only string */

break;

default:

/**

* mate_mixer_device_get_name:

* @device: a #MateMixerDevice

*/

const gchar *

mate_mixer_device_get_name (MateMixerDevice *device)

/**

* mate_mixer_device_get_label:

* @device: a #MateMixerDevice

*/

const gchar *

mate_mixer_device_get_label (MateMixerDevice *device)

/**

* mate_mixer_device_get_icon:

* @device: a #MateMixerDevice

*/

const gchar *

mate_mixer_device_get_icon (MateMixerDevice *device)

* mate_mixer_device_get_stream:

* @device: a #MateMixerDevice

* @name: a stream name

*/

MateMixerStream *

mate_mixer_device_get_stream (MateMixerDevice *device, const gchar *name)

* mate_mixer_device_get_switch:

* @device: a #MateMixerDevice

* @name: a switch name

*/

MateMixerSwitch *

mate_mixer_device_get_switch (MateMixerDevice *device, const gchar *name)

/**

* mate_mixer_device_list_streams:

* @device: a #MateMixerDevice

*/

const GList *

mate_mixer_device_list_streams (MateMixerDevice *device)

/**

* mate_mixer_device_list_switches:

* @device: a #MateMixerDevice

*/

const GList *

mate_mixer_device_list_switches (MateMixerDevice *device)

/**

* MateMixerDeviceClass:

*

*/

struct _MateMixerDeviceClass

{

static const GFlagsValue values[] = {

{ MATE_MIXER_BACKEND_NO_FLAGS, "MATE_MIXER_STREAM_NO_FLAGS", "no-flags" },

{ MATE_MIXER_BACKEND_HAS_APPLICATION_CONTROLS, "MATE_MIXER_BACKEND_HAS_APPLICATION_CONTROLS", "has-application-controls" },

{ MATE_MIXER_BACKEND_CAN_SET_DEFAULT_INPUT_STREAM, "MATE_MIXER_BACKEND_CAN_SET_DEFAULT_INPUT_STREAM", "can-set-default-input-stream" },

{ MATE_MIXER_BACKEND_CAN_SET_DEFAULT_OUTPUT_STREAM, "MATE_MIXER_BACKEND_CAN_SET_DEFAULT_OUTPUT_STREAM", "can-set-default-output-stream" },

{ 0, NULL, NULL }

{ MATE_MIXER_CHANNEL_TOP_BACK_LEFT, "MATE_MIXER_CHANNEL_TOP_BACK_LEFT", "top-back-left" },

{ MATE_MIXER_CHANNEL_TOP_BACK_RIGHT, "MATE_MIXER_CHANNEL_TOP_BACK_RIGHT", "top-back-right" },

{ MATE_MIXER_CHANNEL_TOP_BACK_CENTER, "MATE_MIXER_CHANNEL_TOP_BACK_CENTER", "top-back-center" },

{ 0, NULL, NULL }

};

etype = g_enum_register_static (

/**

* MateMixerState:

* @MATE_MIXER_STATE_IDLE:

* @MATE_MIXER_STATE_CONNECTING:

* @MATE_MIXER_STATE_READY:

* @MATE_MIXER_STATE_FAILED:

* @MATE_MIXER_STATE_UNKNOWN:

*/

typedef enum {

MATE_MIXER_STATE_IDLE,

/**

* MateMixerBackendType:

* @MATE_MIXER_BACKEND_UNKNOWN:

* @MATE_MIXER_BACKEND_PULSEAUDIO:

* PulseAudio sound system backend. It has the highest priority and

* @MATE_MIXER_BACKEND_ALSA:

* @MATE_MIXER_BACKEND_OSS:

* @MATE_MIXER_BACKEND_NULL:

* Fallback backend which never fails to initialize, but provides no

* functionality. This backend has the lowest priority and will be used

*/

typedef enum {

MATE_MIXER_BACKEND_UNKNOWN,

/**

* MateMixerBackendFlags:

*/

typedef enum { /*< flags >*/

} MateMixerBackendFlags;

/**

* MateMixerDirection:

*/

typedef enum {

MATE_MIXER_DIRECTION_UNKNOWN,

/**

* MateMixerStreamControlFlags:

* @MATE_MIXER_STREAM_CONTROL_NO_FLAGS:

* @MATE_MIXER_STREAM_CONTROL_CAN_BALANCE:

* @MATE_MIXER_STREAM_CONTROL_CAN_FADE:

*/

typedef enum {

MATE_MIXER_STREAM_CONTROL_NO_FLAGS = 0,

MATE_MIXER_STREAM_CONTROL_STORED = 1 << 9

} MateMixerStreamControlFlags;

typedef enum {

MATE_MIXER_STREAM_CONTROL_ROLE_UNKNOWN,

MATE_MIXER_STREAM_CONTROL_ROLE_MASTER,

MATE_MIXER_STREAM_CONTROL_ROLE_MUSIC

} MateMixerStreamControlRole;

typedef enum {

MATE_MIXER_STREAM_CONTROL_MEDIA_ROLE_UNKNOWN,

MATE_MIXER_STREAM_CONTROL_MEDIA_ROLE_VIDEO,

MATE_MIXER_STREAM_CONTROL_MEDIA_ROLE_FILTER

} MateMixerStreamControlMediaRole;

typedef enum { /*< flags >*/

MATE_MIXER_SWITCH_NO_FLAGS = 0,

MATE_MIXER_SWITCH_TOGGLE = 1 << 0,

MATE_MIXER_SWITCH_ALLOWS_NO_ACTIVE_OPTION = 1 << 1

} MateMixerSwitchFlags;

typedef enum {

MATE_MIXER_SWITCH_ROLE_UNKNOWN,

MATE_MIXER_SWITCH_ROLE_DEVICE_PROFILE,

/**

* MateMixerChannelPosition:

* @MATE_MIXER_CHANNEL_UNKNOWN:

* @MATE_MIXER_CHANNEL_MONO:

* @MATE_MIXER_CHANNEL_FRONT_LEFT:

* @MATE_MIXER_CHANNEL_FRONT_RIGHT:

* @MATE_MIXER_CHANNEL_FRONT_CENTER:

* @MATE_MIXER_CHANNEL_LFE:

* @MATE_MIXER_CHANNEL_BACK_LEFT:

* @MATE_MIXER_CHANNEL_BACK_RIGHT:

* @MATE_MIXER_CHANNEL_BACK_CENTER:

* @MATE_MIXER_CHANNEL_FRONT_LEFT_CENTER:

* @MATE_MIXER_CHANNEL_FRONT_RIGHT_CENTER:

* @MATE_MIXER_CHANNEL_SIDE_LEFT:

* @MATE_MIXER_CHANNEL_SIDE_RIGHT:

* @MATE_MIXER_CHANNEL_TOP_FRONT_LEFT:

* @MATE_MIXER_CHANNEL_TOP_FRONT_RIGHT:

* @MATE_MIXER_CHANNEL_TOP_FRONT_CENTER:

* @MATE_MIXER_CHANNEL_TOP_CENTER:

* @MATE_MIXER_CHANNEL_TOP_BACK_LEFT:

* @MATE_MIXER_CHANNEL_TOP_BACK_RIGHT:

* @MATE_MIXER_CHANNEL_TOP_BACK_CENTER:

*/

typedef enum {

MATE_MIXER_CHANNEL_UNKNOWN = 0,

MATE_MIXER_CHANNEL_TOP_BACK_LEFT,

MATE_MIXER_CHANNEL_TOP_BACK_RIGHT,

MATE_MIXER_CHANNEL_TOP_BACK_CENTER,

MATE_MIXER_CHANNEL_MAX

} MateMixerChannelPosition;

#define MATE_MIXER_CHANNEL_MASK_HAS_FRONT(m) ((m) & MATE_MIXER_CHANNEL_MASK_FRONT)

#define MATE_MIXER_CHANNEL_MASK_HAS_BACK(m) ((m) & MATE_MIXER_CHANNEL_MASK_BACK)

const GList *_mate_mixer_list_modules (void);

G_END_DECLS

#include "matemixer-stream-control.h"

#include "matemixer-stored-control.h"

static void

{

}

/**

{

g_return_val_if_fail (MATE_MIXER_IS_STORED_CONTROL (control), MATE_MIXER_DIRECTION_UNKNOWN);

}

#include <glib-object.h>

#include <libmatemixer/matemixer-enums.h>

#include <libmatemixer/matemixer-types.h>

G_BEGIN_DECLS

(mate_mixer_stored_control_get_type ())

(G_TYPE_CHECK_INSTANCE_CAST ((o), MATE_MIXER_TYPE_STORED_CONTROL, MateMixerStoredControl))

(G_TYPE_CHECK_INSTANCE_TYPE ((o), MATE_MIXER_TYPE_STORED_CONTROL))

/**

*

*/

{

/*< private >*/

};

GType mate_mixer_stored_control_get_type (void) G_GNUC_CONST;

GParamSpec *pspec);

static void mate_mixer_stream_control_init (MateMixerStreamControl *control);

static void mate_mixer_stream_control_finalize (GObject *object);

G_DEFINE_ABSTRACT_TYPE (MateMixerStreamControl, mate_mixer_stream_control, G_TYPE_OBJECT)

GObjectClass *object_class;

object_class = G_OBJECT_CLASS (klass);

object_class->finalize = mate_mixer_stream_control_finalize;

object_class->get_property = mate_mixer_stream_control_get_property;

object_class->set_property = mate_mixer_stream_control_set_property;

/* Construct-only object */

control->priv->stream = g_value_get_object (value);

g_object_add_weak_pointer (G_OBJECT (control->priv->stream),

(gpointer *) &control->priv->stream);

break;

default:

}

static void

mate_mixer_stream_control_finalize (GObject *object)

{

MateMixerStreamControl *control;

g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), NULL);

if (control->priv->role == MATE_MIXER_STREAM_CONTROL_ROLE_APPLICATION) {

}

return NULL;

}

/**

* mate_mixer_stream_control_set_stream:

* @control: a #MateMixerStreamControl

*/

gboolean

mate_mixer_stream_control_set_stream (MateMixerStreamControl *control,

MateMixerStream *stream)

{

return FALSE;

_mate_mixer_stream_control_set_stream (control, stream);

}

return TRUE;

}

/**

* mate_mixer_stream_control_set_mute:

* @control: a #MateMixerStreamControl

*/

gboolean

mate_mixer_stream_control_set_mute (MateMixerStreamControl *control, gboolean mute)

{

g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), FALSE);

}

}

/**

klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control);

if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_VOLUME_READABLE) {

}

return klass->get_min_volume (control);

}

/**

* mate_mixer_stream_control_set_volume:

* @control: a #MateMixerStreamControl

*/

gboolean

mate_mixer_stream_control_set_volume (MateMixerStreamControl *control, guint volume)

g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), FALSE);

if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_VOLUME_WRITABLE) {

}

return FALSE;

}

{

g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), -MATE_MIXER_INFINITY);

}

return -MATE_MIXER_INFINITY;

}

/**

* mate_mixer_stream_control_set_decibel:

* @control: a #MateMixerStreamControl

*/

gboolean

mate_mixer_stream_control_set_decibel (MateMixerStreamControl *control, gdouble decibel)

if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_HAS_DECIBEL &&

control->priv->flags & MATE_MIXER_STREAM_CONTROL_VOLUME_WRITABLE) {

}

return FALSE;

}

/**

* mate_mixer_stream_control_has_channel_position:

* @control: a #MateMixerStreamControl

*/

gboolean

{

MateMixerStreamControlClass *klass;

/**

* mate_mixer_stream_control_get_channel_position:

* @control: a #MateMixerStreamControl

*/

MateMixerChannelPosition

mate_mixer_stream_control_get_channel_position (MateMixerStreamControl *control, guint channel)

/**

* mate_mixer_stream_control_get_channel_volume:

* @control: a #MateMixerStreamControl

*/

guint

mate_mixer_stream_control_get_channel_volume (MateMixerStreamControl *control, guint channel)

{

}

}

/**

* mate_mixer_stream_control_set_channel_volume:

* @control: a #MateMixerStreamControl

*/

gboolean

mate_mixer_stream_control_set_channel_volume (MateMixerStreamControl *control,

{

g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), FALSE);

}

return FALSE;

}

/**

* mate_mixer_stream_control_get_channel_decibel:

* @control: a #MateMixerStreamControl

*/

gdouble

mate_mixer_stream_control_get_channel_decibel (MateMixerStreamControl *control, guint channel)

{

g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), -MATE_MIXER_INFINITY);

}

return -MATE_MIXER_INFINITY;

}

/**

* mate_mixer_stream_control_set_channel_decibel:

* @control: a #MateMixerStreamControl

*/

gboolean

mate_mixer_stream_control_set_channel_decibel (MateMixerStreamControl *control,

{

g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), FALSE);

}

return FALSE;

}

/**

* mate_mixer_stream_control_set_balance:

* @control: a #MateMixerStreamControl

*/

gboolean

mate_mixer_stream_control_set_balance (MateMixerStreamControl *control, gfloat balance)

{

g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), FALSE);

}

}

/**

/**

* mate_mixer_stream_control_set_fade:

* @control: a #MateMixerStreamControl

*/

gboolean

mate_mixer_stream_control_set_fade (MateMixerStreamControl *control, gfloat fade)

{

g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), FALSE);

}

}

/**

g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), FALSE);

if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_HAS_MONITOR) {

}

return FALSE;

}

/**

* mate_mixer_stream_control_set_monitor_enabled:

* @control: a #MateMixerStreamControl

*/

gboolean

mate_mixer_stream_control_set_monitor_enabled (MateMixerStreamControl *control, gboolean enabled)

{

g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), FALSE);

}

/**

guint

mate_mixer_stream_control_get_min_volume (MateMixerStreamControl *control)

{

g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), 0);

}

/**

guint

mate_mixer_stream_control_get_max_volume (MateMixerStreamControl *control)

{

g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), 0);

}

/**

guint

mate_mixer_stream_control_get_normal_volume (MateMixerStreamControl *control)

{

g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), 0);

}

/**

guint

mate_mixer_stream_control_get_base_volume (MateMixerStreamControl *control)

{

g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), 0);

}

/* Protected functions */

g_object_notify_by_pspec (G_OBJECT (control), properties[PROP_FLAGS]);

}

void

_mate_mixer_stream_control_set_stream (MateMixerStreamControl *control,

MateMixerStream *stream)

return;

if (control->priv->stream != NULL)

control->priv->stream = NULL;

g_object_notify_by_pspec (G_OBJECT (control), properties[PROP_STREAM]);

/**

* MateMixerStreamControlClass:

*

*/

struct _MateMixerStreamControlClass

{

GObjectClass parent_class;

/*< private >*/

/* Signals */

};

GType mate_mixer_stream_control_get_type (void) G_GNUC_CONST;

G_END_DECLS

/* Construct-only object */

stream->priv->device = g_value_get_object (value);

g_object_add_weak_pointer (G_OBJECT (stream->priv->device),

(gpointer *) &stream->priv->device);

break;

case PROP_DEFAULT_CONTROL:

/* Construct-only object */

stream = MATE_MIXER_STREAM (object);

g_free (stream->priv->name);

G_OBJECT_CLASS (mate_mixer_stream_parent_class)->finalize (object);

}

/**

* mate_mixer_stream_get_control:

* @stream: a #MateMixerStream

*/

MateMixerStreamControl *

mate_mixer_stream_get_control (MateMixerStream *stream, const gchar *name)

/**

* mate_mixer_stream_get_switch:

* @stream: a #MateMixerStream

*/

MateMixerSwitch *

mate_mixer_stream_get_switch (MateMixerStream *stream, const gchar *name)

const GList *

mate_mixer_stream_list_controls (MateMixerStream *stream)

{

g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), NULL);

}

/**

const GList *

mate_mixer_stream_list_switches (MateMixerStream *stream)

{

g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), NULL);

}

static MateMixerStreamControl *

mate_mixer_stream_get_name (stream));

}

}

/**

* MateMixerStreamClass:

*

*/

struct _MateMixerStreamClass

{

const gchar * mate_mixer_stream_get_name (MateMixerStream *stream);

const gchar * mate_mixer_stream_get_label (MateMixerStream *stream);

MateMixerDirection mate_mixer_stream_get_direction (MateMixerStream *stream);

MateMixerDevice * mate_mixer_stream_get_device (MateMixerStream *stream);

#include "matemixer-switch-option-private.h"

/**

* @include: libmatemixer/matemixer.h

*/

object_class->get_property = mate_mixer_switch_option_get_property;

object_class->set_property = mate_mixer_switch_option_set_property;

properties[PROP_NAME] =

g_param_spec_string ("name",

"Name",

G_PARAM_CONSTRUCT_ONLY |

G_PARAM_STATIC_STRINGS);

properties[PROP_LABEL] =

g_param_spec_string ("label",

"Label",

G_PARAM_CONSTRUCT_ONLY |

G_PARAM_STATIC_STRINGS);

properties[PROP_ICON] =

g_param_spec_string ("icon",

"Icon",

/**

* mate_mixer_switch_option_get_name:

*/

const gchar *

mate_mixer_switch_option_get_name (MateMixerSwitchOption *option)

/**

* mate_mixer_switch_option_get_label:

*/

const gchar *

mate_mixer_switch_option_get_label (MateMixerSwitchOption *option)

/**

* mate_mixer_switch_option_get_icon:

*/

const gchar *

mate_mixer_switch_option_get_icon (MateMixerSwitchOption *option)

/**

* MateMixerSwitchOptionClass:

*

*/

struct _MateMixerSwitchOptionClass

{

/**

* mate_mixer_switch_get_name:

* @swtch: a #MateMixerSwitch

*/

const gchar *

mate_mixer_switch_get_name (MateMixerSwitch *swtch)

/**

* mate_mixer_switch_get_label:

* @swtch: a #MateMixerSwitch

*/

const gchar *

mate_mixer_switch_get_label (MateMixerSwitch *swtch)

/**

* mate_mixer_switch_get_flags:

* @swtch: a #MateMixerSwitch

*/

MateMixerSwitchFlags

mate_mixer_switch_get_flags (MateMixerSwitch *swtch)

/**

* mate_mixer_switch_get_role:

* @swtch: a #MateMixerSwitch

*/

MateMixerSwitchRole

mate_mixer_switch_get_role (MateMixerSwitch *swtch)

/**

* mate_mixer_switch_get_option:

* @swtch: a #MateMixerSwitch

*/

MateMixerSwitchOption *

mate_mixer_switch_get_option (MateMixerSwitch *swtch, const gchar *name)

/**

* mate_mixer_switch_get_active_option:

* @swtch: a #MateMixerSwitch

*/

MateMixerSwitchOption *

mate_mixer_switch_get_active_option (MateMixerSwitch *swtch)

/**

* mate_mixer_switch_set_active_option:

* @swtch: a #MateMixerSwitch

*/

gboolean

mate_mixer_switch_set_active_option (MateMixerSwitch *swtch,

MateMixerSwitchOption *option)

{

g_return_val_if_fail (MATE_MIXER_IS_SWITCH (swtch), FALSE);

return FALSE;

_mate_mixer_switch_set_active_option (swtch, option);

}

/**

* @swtch: a #MateMixerSwitch

*/

const GList *

mate_mixer_switch_list_options (MateMixerSwitch *swtch)

else

swtch->priv->active = NULL;

}

static MateMixerSwitchOption *

G_BEGIN_DECLS

(mate_mixer_switch_get_type ())

(G_TYPE_CHECK_INSTANCE_CAST ((o), MATE_MIXER_TYPE_SWITCH, MateMixerSwitch))

(G_TYPE_CHECK_INSTANCE_TYPE ((o), MATE_MIXER_TYPE_SWITCH))

(G_TYPE_CHECK_CLASS_CAST ((k), MATE_MIXER_TYPE_SWITCH, MateMixerSwitchClass))

(G_TYPE_CHECK_CLASS_TYPE ((k), MATE_MIXER_TYPE_SWITCH))

(G_TYPE_INSTANCE_GET_CLASS ((o), MATE_MIXER_TYPE_SWITCH, MateMixerSwitchClass))

typedef struct _MateMixerSwitchClass MateMixerSwitchClass;

/**

* MateMixerSwitchClass:

*

*/

struct _MateMixerSwitchClass

{

* License along with this library; if not, see <http://www.gnu.org/licenses/>.

*/

#include <glib.h>

#include <glib-object.h>

/**

* SECTION:matemixer-toggle

* @include: libmatemixer/matemixer.h

*/

enum {

PROP_0,

PROP_STATE,

N_PROPERTIES

};

switch_class->get_option = mate_mixer_toggle_get_option;

switch_class->list_options = mate_mixer_toggle_list_options;

properties[PROP_STATE] =

g_param_spec_boolean ("state",

"State",

"Current state of the toggle",

FALSE,

G_PARAM_STATIC_STRINGS);

MATE_MIXER_TYPE_SWITCH_OPTION,

G_PARAM_READWRITE |

G_PARAM_CONSTRUCT_ONLY |

G_PARAM_STATIC_STRINGS);

MATE_MIXER_TYPE_SWITCH_OPTION,

G_PARAM_READWRITE |

G_PARAM_CONSTRUCT_ONLY |

case PROP_STATE:

g_value_set_boolean (value, mate_mixer_toggle_get_state (toggle));

break;

g_value_set_object (value, toggle->priv->on);

break;

g_value_set_object (value, toggle->priv->off);

break;

toggle = MATE_MIXER_TOGGLE (object);

switch (param_id) {

/* Construct-only object */

toggle->priv->on = g_value_dup_object (value);

break;

/* Construct-only object */

toggle->priv->off = g_value_dup_object (value);

break;

toggle = MATE_MIXER_TOGGLE (object);

if (toggle->priv->options != NULL) {

toggle->priv->options = NULL;

}

g_clear_object (&toggle->priv->on);

g_clear_object (&toggle->priv->off);

/**

* mate_mixer_toggle_get_state:

* @toggle: a #MateMixerToggle

*/

gboolean

mate_mixer_toggle_get_state (MateMixerToggle *toggle)

g_return_val_if_fail (MATE_MIXER_IS_TOGGLE (toggle), FALSE);

active = mate_mixer_switch_get_active_option (MATE_MIXER_SWITCH (toggle));

if (active == toggle->priv->on)

return TRUE;

else

/**

* mate_mixer_toggle_get_state_option:

* @toggle: a #MateMixerToggle

*/

MateMixerSwitchOption *

mate_mixer_toggle_get_state_option (MateMixerToggle *toggle, gboolean state)

/**

* mate_mixer_toggle_set_state:

* @toggle: a #MateMixerToggle

*/

gboolean

mate_mixer_toggle_set_state (MateMixerToggle *toggle, gboolean state)

else

active = toggle->priv->off;

return mate_mixer_switch_set_active_option (MATE_MIXER_SWITCH (toggle), active);

}

MateMixerToggle *toggle;

g_return_val_if_fail (MATE_MIXER_IS_TOGGLE (swtch), NULL);

toggle = MATE_MIXER_TOGGLE (swtch);

return toggle->priv->on;

return toggle->priv->off;

return NULL;

toggle = MATE_MIXER_TOGGLE (swtch);

if (toggle->priv->options == NULL) {

}

return toggle->priv->options;

}

/**

* MateMixerToggleClass:

*

*/

struct _MateMixerToggleClass

{

G_BEGIN_DECLS

typedef struct _MateMixerAppInfo MateMixerAppInfo;

typedef struct _MateMixerContext MateMixerContext;

typedef struct _MateMixerStoredControl MateMixerStoredControl;

typedef struct _MateMixerStream MateMixerStream;

typedef struct _MateMixerStreamControl MateMixerStreamControl;

/**

* SECTION:matemixer

* @short_description: Library initialization and support functions

* @include: libmatemixer/matemixer.h

*/

static void load_modules (void);

return initialized;

}

const GList *

_mate_mixer_list_modules (void)

{

return (const GList *) modules;

}

guint32

_mate_mixer_create_channel_mask (MateMixerChannelPosition *positions, guint n)

{

if (loaded == TRUE)

return;

GDir *dir;

GError *error = NULL;

g_error_free (error);

}

} else {

}

loaded = TRUE;

}

static gint

compare_modules (gconstpointer a, gconstpointer b)

{