vlc_variables.h 21.2 KB
Newer Older
1
/*****************************************************************************
Pere Orga's avatar
Pere Orga committed
2
 * vlc_variables.h: variables handling
3
 *****************************************************************************
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
4
 * Copyright (C) 2002-2004 VLC authors and VideoLAN
5
 * $Id$
6 7
 *
 * Authors: Samuel Hocevar <sam@zoy.org>
8
 *          Gildas Bazin <gbazin@netcourrier.com>
9
 *
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
10 11 12
 * This program 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 2.1 of the License, or
13
 * (at your option) any later version.
14
 *
15 16
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
17 18
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
19
 *
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
20 21 22
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23 24
 *****************************************************************************/

25 26
#ifndef VLC_VARIABLES_H
#define VLC_VARIABLES_H 1
27

Sigmund Augdal Helberg's avatar
Sigmund Augdal Helberg committed
28 29
/**
 * \defgroup variables Variables
30
 * \ingroup vlc_object
Sigmund Augdal Helberg's avatar
Sigmund Augdal Helberg committed
31
 *
32
 * VLC object variables and callbacks
Sigmund Augdal Helberg's avatar
Sigmund Augdal Helberg committed
33 34
 *
 * @{
35 36
 * \file
 * VLC object variables and callbacks interface
Sigmund Augdal Helberg's avatar
Sigmund Augdal Helberg committed
37 38
 */

39
#define VLC_VAR_TYPE      0x00ff
40
#define VLC_VAR_CLASS     0x00f0
41 42
#define VLC_VAR_FLAGS     0xff00

43 44 45 46 47 48 49 50 51 52 53 54 55 56
/**
 * \defgroup var_type Variable types
 * These are the different types a vlc variable can have.
 * @{
 */
#define VLC_VAR_VOID      0x0010
#define VLC_VAR_BOOL      0x0020
#define VLC_VAR_INTEGER   0x0030
#define VLC_VAR_STRING    0x0040
#define VLC_VAR_FLOAT     0x0050
#define VLC_VAR_ADDRESS   0x0070
#define VLC_VAR_COORDS    0x00A0
/**@}*/

Sigmund Augdal Helberg's avatar
Sigmund Augdal Helberg committed
57 58
/** \defgroup var_flags Additive flags
 * These flags are added to the type field of the variable. Most as a result of
59
 * a var_Change() call, but some may be added at creation time
Sigmund Augdal Helberg's avatar
Sigmund Augdal Helberg committed
60 61
 * @{
 */
62
#define VLC_VAR_HASCHOICE 0x0100
63

64
#define VLC_VAR_ISCOMMAND 0x2000
65

Sigmund Augdal Helberg's avatar
Sigmund Augdal Helberg committed
66
/** Creation flag */
basos G's avatar
basos G committed
67 68
/* If the variable is not found on the current module
   search all parents and finally module config until found */
69
#define VLC_VAR_DOINHERIT 0x8000
Sigmund Augdal Helberg's avatar
Sigmund Augdal Helberg committed
70
/**@}*/
71

Sigmund Augdal Helberg's avatar
Sigmund Augdal Helberg committed
72 73
/**
 * \defgroup var_action Variable actions
74
 * These are the different actions that can be used with var_Change().
Sigmund Augdal Helberg's avatar
Sigmund Augdal Helberg committed
75
 * The parameters given are the meaning of the two last parameters of
76
 * var_Change() when this action is being used.
Sigmund Augdal Helberg's avatar
Sigmund Augdal Helberg committed
77 78 79
 * @{
 */

Derk-Jan Hartman's avatar
Derk-Jan Hartman committed
80
#define VLC_VAR_SETSTEP             0x0012
81

Sigmund Augdal Helberg's avatar
Sigmund Augdal Helberg committed
82 83 84 85 86
/**
 * Set the value of this variable without triggering any callbacks
 * \param p_val The new value
 * \param p_val2 Unused
 */
Derk-Jan Hartman's avatar
Derk-Jan Hartman committed
87 88 89 90 91
#define VLC_VAR_SETVALUE            0x0013

#define VLC_VAR_SETTEXT             0x0014
#define VLC_VAR_GETTEXT             0x0015

92 93 94 95
#define VLC_VAR_GETMIN              0x0016
#define VLC_VAR_GETMAX              0x0017
#define VLC_VAR_GETSTEP             0x0018

Derk-Jan Hartman's avatar
Derk-Jan Hartman committed
96 97 98 99
#define VLC_VAR_ADDCHOICE           0x0020
#define VLC_VAR_DELCHOICE           0x0021
#define VLC_VAR_CLEARCHOICES        0x0022
#define VLC_VAR_GETCHOICES          0x0024
100

Rémi Duraffort's avatar
Rémi Duraffort committed
101
#define VLC_VAR_CHOICESCOUNT        0x0026
102
#define VLC_VAR_SETMINMAX           0x0027
Derk-Jan Hartman's avatar
Derk-Jan Hartman committed
103

Sigmund Augdal Helberg's avatar
Sigmund Augdal Helberg committed
104
/**@}*/
105

106
/** \defgroup var_GetAndSet Variable actions
107
 * These are the different actions that can be used with var_GetAndSet()
108 109
 * @{
 */
110 111 112 113 114 115
enum {
    VLC_VAR_BOOL_TOGGLE, /**< Invert a boolean value (param ignored) */
    VLC_VAR_INTEGER_ADD, /**< Add parameter to an integer value */
    VLC_VAR_INTEGER_OR,  /**< Binary OR over an integer bits field */
    VLC_VAR_INTEGER_NAND,/**< Binary NAND over an integer bits field */
};
116 117
/**@}*/

118 119 120
/*****************************************************************************
 * Prototypes
 *****************************************************************************/
121
VLC_API int var_Create( vlc_object_t *, const char *, int );
122
#define var_Create(a,b,c) var_Create( VLC_OBJECT(a), b, c )
123

124
VLC_API void var_Destroy( vlc_object_t *, const char * );
125 126
#define var_Destroy(a,b) var_Destroy( VLC_OBJECT(a), b )

127
VLC_API int var_Change( vlc_object_t *, const char *, int, vlc_value_t *, vlc_value_t * );
128 129
#define var_Change(a,b,c,d,e) var_Change( VLC_OBJECT(a), b, c, d, e )

130
VLC_API int var_Type( vlc_object_t *, const char * ) VLC_USED;
131 132
#define var_Type(a,b) var_Type( VLC_OBJECT(a), b )

133
VLC_API int var_Set( vlc_object_t *, const char *, vlc_value_t );
134 135
#define var_Set(a,b,c) var_Set( VLC_OBJECT(a), b, c )

136
VLC_API int var_Get( vlc_object_t *, const char *, vlc_value_t * );
137
#define var_Get(a,b,c) var_Get( VLC_OBJECT(a), b, c )
138

139
VLC_API int var_SetChecked( vlc_object_t *, const char *, int, vlc_value_t );
140
#define var_SetChecked(o,n,t,v) var_SetChecked(VLC_OBJECT(o),n,t,v)
141
VLC_API int var_GetChecked( vlc_object_t *, const char *, int, vlc_value_t * );
142
#define var_GetChecked(o,n,t,v) var_GetChecked(VLC_OBJECT(o),n,t,v)
143
VLC_API int var_GetAndSet( vlc_object_t *, const char *, int, vlc_value_t * );
144

145
VLC_API int var_Inherit( vlc_object_t *, const char *, int, vlc_value_t * );
146

147
VLC_API void var_FreeList( vlc_value_t *, vlc_value_t * );
148

149

150 151 152 153 154 155 156 157 158
/*****************************************************************************
 * Variable callbacks
 *****************************************************************************
 * int MyCallback( vlc_object_t *p_this,
 *                 char const *psz_variable,
 *                 vlc_value_t oldvalue,
 *                 vlc_value_t newvalue,
 *                 void *p_data);
 *****************************************************************************/
159
VLC_API void var_AddCallback( vlc_object_t *, const char *, vlc_callback_t, void * );
160
VLC_API void var_DelCallback( vlc_object_t *, const char *, vlc_callback_t, void * );
161
VLC_API void var_TriggerCallback( vlc_object_t *, const char * );
162

163
VLC_API void var_AddListCallback( vlc_object_t *, const char *, vlc_list_callback_t, void * );
164
VLC_API void var_DelListCallback( vlc_object_t *, const char *, vlc_list_callback_t, void * );
165

166 167 168
#define var_AddCallback(a,b,c,d) var_AddCallback( VLC_OBJECT(a), b, c, d )
#define var_DelCallback(a,b,c,d) var_DelCallback( VLC_OBJECT(a), b, c, d )
#define var_TriggerCallback(a,b) var_TriggerCallback( VLC_OBJECT(a), b )
169

170 171 172
#define var_AddListCallback(a,b,c,d) var_AddListCallback( VLC_OBJECT(a), b, c, d )
#define var_DelListCallback(a,b,c,d) var_DelListCallback( VLC_OBJECT(a), b, c, d )

173 174 175
/*****************************************************************************
 * helpers functions
 *****************************************************************************/
Sigmund Augdal Helberg's avatar
Sigmund Augdal Helberg committed
176 177 178 179 180 181 182 183

/**
 * Set the value of an integer variable
 *
 * \param p_obj The object that holds the variable
 * \param psz_name The name of the variable
 * \param i The new integer value of this variable
 */
184 185
static inline int var_SetInteger( vlc_object_t *p_obj, const char *psz_name,
                                  int64_t i )
186 187 188
{
    vlc_value_t val;
    val.i_int = i;
189
    return var_SetChecked( p_obj, psz_name, VLC_VAR_INTEGER, val );
190
}
Rémi Duraffort's avatar
Rémi Duraffort committed
191

192 193 194 195 196
/**
 * Set the value of an boolean variable
 *
 * \param p_obj The object that holds the variable
 * \param psz_name The name of the variable
197
 * \param b The new boolean value of this variable
198
 */
199
static inline int var_SetBool( vlc_object_t *p_obj, const char *psz_name, bool b )
200 201 202
{
    vlc_value_t val;
    val.b_bool = b;
203
    return var_SetChecked( p_obj, psz_name, VLC_VAR_BOOL, val );
204 205
}

206 207 208 209 210 211 212 213 214 215
static inline int var_SetCoords( vlc_object_t *obj, const char *name,
                                 int32_t x, int32_t y )
{
    vlc_value_t val;
    val.coords.x = x;
    val.coords.y = y;
    return var_SetChecked (obj, name, VLC_VAR_COORDS, val);
}
#define var_SetCoords(o,n,x,y) var_SetCoords(VLC_OBJECT(o),n,x,y)

Sigmund Augdal Helberg's avatar
Sigmund Augdal Helberg committed
216 217 218 219 220 221 222
/**
 * Set the value of a float variable
 *
 * \param p_obj The object that holds the variable
 * \param psz_name The name of the variable
 * \param f The new float value of this variable
 */
223
static inline int var_SetFloat( vlc_object_t *p_obj, const char *psz_name, float f )
224 225 226
{
    vlc_value_t val;
    val.f_float = f;
227
    return var_SetChecked( p_obj, psz_name, VLC_VAR_FLOAT, val );
228
}
Sigmund Augdal Helberg's avatar
Sigmund Augdal Helberg committed
229

230 231 232 233 234 235 236
/**
 * Set the value of a string variable
 *
 * \param p_obj The object that holds the variable
 * \param psz_name The name of the variable
 * \param psz_string The new string value of this variable
 */
237
static inline int var_SetString( vlc_object_t *p_obj, const char *psz_name, const char *psz_string )
238 239
{
    vlc_value_t val;
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
240
    val.psz_string = (char *)psz_string;
241
    return var_SetChecked( p_obj, psz_name, VLC_VAR_STRING, val );
242 243
}

244 245 246 247 248 249 250 251
/**
 * Set the value of a pointer variable
 *
 * \param p_obj The object that holds the variable
 * \param psz_name The name of the variable
 * \param ptr The new pointer value of this variable
 */
static inline
252
int var_SetAddress( vlc_object_t *p_obj, const char *psz_name, void *ptr )
253 254 255 256 257 258
{
    vlc_value_t val;
    val.p_address = ptr;
    return var_SetChecked( p_obj, psz_name, VLC_VAR_ADDRESS, val );
}

259 260 261 262 263
#define var_SetInteger(a,b,c)   var_SetInteger( VLC_OBJECT(a),b,c)
#define var_SetBool(a,b,c)      var_SetBool( VLC_OBJECT(a),b,c)
#define var_SetFloat(a,b,c)     var_SetFloat( VLC_OBJECT(a),b,c)
#define var_SetString(a,b,c)    var_SetString( VLC_OBJECT(a),b,c)
#define var_SetAddress(o, n, p) var_SetAddress(VLC_OBJECT(o), n, p)
Rémi Duraffort's avatar
Rémi Duraffort committed
264

265

266
/**
267 268
 * Get an integer value
*
269 270 271
 * \param p_obj The object that holds the variable
 * \param psz_name The name of the variable
 */
272
VLC_USED
273
static inline int64_t var_GetInteger( vlc_object_t *p_obj, const char *psz_name )
274
{
275 276
    vlc_value_t val;
    if( !var_GetChecked( p_obj, psz_name, VLC_VAR_INTEGER, &val ) )
277 278 279 280 281
        return val.i_int;
    else
        return 0;
}

282 283 284 285 286 287
/**
 * Get a boolean value
 *
 * \param p_obj The object that holds the variable
 * \param psz_name The name of the variable
 */
288
VLC_USED
289
static inline bool var_GetBool( vlc_object_t *p_obj, const char *psz_name )
290
{
291
    vlc_value_t val; val.b_bool = false;
292

293
    if( !var_GetChecked( p_obj, psz_name, VLC_VAR_BOOL, &val ) )
294 295
        return val.b_bool;
    else
296
        return false;
297 298
}

299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
static inline void var_GetCoords( vlc_object_t *obj, const char *name,
                                  int32_t *px, int32_t *py )
{
    vlc_value_t val;

    if (likely(!var_GetChecked (obj, name, VLC_VAR_COORDS, &val)))
    {
        *px = val.coords.x;
        *py = val.coords.y;
    }
    else
        *px = *py = 0;
}
#define var_GetCoords(o,n,x,y) var_GetCoords(VLC_OBJECT(o),n,x,y)

314 315 316 317 318 319
/**
 * Get a float value
 *
 * \param p_obj The object that holds the variable
 * \param psz_name The name of the variable
 */
320
VLC_USED
321
static inline float var_GetFloat( vlc_object_t *p_obj, const char *psz_name )
322
{
Clément Stenac's avatar
Clément Stenac committed
323
    vlc_value_t val; val.f_float = 0.0;
324
    if( !var_GetChecked( p_obj, psz_name, VLC_VAR_FLOAT, &val ) )
325 326 327 328 329 330 331 332 333 334 335
        return val.f_float;
    else
        return 0.0;
}

/**
 * Get a string value
 *
 * \param p_obj The object that holds the variable
 * \param psz_name The name of the variable
 */
336
VLC_USED VLC_MALLOC
337
static inline char *var_GetString( vlc_object_t *p_obj, const char *psz_name )
338
{
Clément Stenac's avatar
Clément Stenac committed
339
    vlc_value_t val; val.psz_string = NULL;
340
    if( var_GetChecked( p_obj, psz_name, VLC_VAR_STRING, &val ) )
341
        return NULL;
342
    else
343
        return val.psz_string;
344 345
}

346
VLC_USED VLC_MALLOC
347
static inline char *var_GetNonEmptyString( vlc_object_t *p_obj, const char *psz_name )
348 349
{
    vlc_value_t val;
350
    if( var_GetChecked( p_obj, psz_name, VLC_VAR_STRING, &val ) )
351
        return NULL;
352
    if( val.psz_string && *val.psz_string )
353
        return val.psz_string;
354
    free( val.psz_string );
355 356 357
    return NULL;
}

358
VLC_USED
359
static inline void *var_GetAddress( vlc_object_t *p_obj, const char *psz_name )
360 361 362 363 364 365 366
{
    vlc_value_t val;
    if( var_GetChecked( p_obj, psz_name, VLC_VAR_ADDRESS, &val ) )
        return NULL;
    else
        return val.p_address;
}
367

368 369 370 371 372
/**
 * Increment an integer variable
 * \param p_obj the object that holds the variable
 * \param psz_name the name of the variable
 */
373
static inline int64_t var_IncInteger( vlc_object_t *p_obj, const char *psz_name )
374
{
375 376
    vlc_value_t val;
    val.i_int = 1;
377 378
    if( var_GetAndSet( p_obj, psz_name, VLC_VAR_INTEGER_ADD, &val ) )
        return 0;
379
    return val.i_int;
380
}
381
#define var_IncInteger(a,b) var_IncInteger( VLC_OBJECT(a), b )
382 383 384 385 386 387

/**
 * Decrement an integer variable
 * \param p_obj the object that holds the variable
 * \param psz_name the name of the variable
 */
388
static inline int64_t var_DecInteger( vlc_object_t *p_obj, const char *psz_name )
389
{
390 391
    vlc_value_t val;
    val.i_int = -1;
392 393
    if( var_GetAndSet( p_obj, psz_name, VLC_VAR_INTEGER_ADD, &val ) )
        return 0;
394
    return val.i_int;
395
}
396
#define var_DecInteger(a,b) var_DecInteger( VLC_OBJECT(a), b )
397

398
static inline uint64_t var_OrInteger( vlc_object_t *obj, const char *name,
399 400 401 402
                                      unsigned v )
{
    vlc_value_t val;
    val.i_int = v;
403 404
    if( var_GetAndSet( obj, name, VLC_VAR_INTEGER_OR, &val ) )
        return 0;
405 406 407 408
    return val.i_int;
}
#define var_OrInteger(a,b,c) var_OrInteger(VLC_OBJECT(a),b,c)

409
static inline uint64_t var_NAndInteger( vlc_object_t *obj, const char *name,
410 411 412 413
                                        unsigned v )
{
    vlc_value_t val;
    val.i_int = v;
414 415
    if( var_GetAndSet( obj, name, VLC_VAR_INTEGER_NAND, &val ) )
        return 0;
416 417 418 419
    return val.i_int;
}
#define var_NAndInteger(a,b,c) var_NAndInteger(VLC_OBJECT(a),b,c)

420 421 422 423 424 425
/**
 * Create a integer variable with inherit and get its value.
 *
 * \param p_obj The object that holds the variable
 * \param psz_name The name of the variable
 */
426
VLC_USED
427
static inline int64_t var_CreateGetInteger( vlc_object_t *p_obj, const char *psz_name )
428
{
429 430
    var_Create( p_obj, psz_name, VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
    return var_GetInteger( p_obj, psz_name );
431 432
}

433 434 435 436 437 438
/**
 * Create a boolean variable with inherit and get its value.
 *
 * \param p_obj The object that holds the variable
 * \param psz_name The name of the variable
 */
439
VLC_USED
440
static inline bool var_CreateGetBool( vlc_object_t *p_obj, const char *psz_name )
441
{
442 443
    var_Create( p_obj, psz_name, VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
    return var_GetBool( p_obj, psz_name );
444 445
}

446 447 448 449 450 451
/**
 * Create a float variable with inherit and get its value.
 *
 * \param p_obj The object that holds the variable
 * \param psz_name The name of the variable
 */
452
VLC_USED
453
static inline float var_CreateGetFloat( vlc_object_t *p_obj, const char *psz_name )
454
{
455 456
    var_Create( p_obj, psz_name, VLC_VAR_FLOAT | VLC_VAR_DOINHERIT );
    return var_GetFloat( p_obj, psz_name );
457 458 459 460 461 462 463 464
}

/**
 * Create a string variable with inherit and get its value.
 *
 * \param p_obj The object that holds the variable
 * \param psz_name The name of the variable
 */
465
VLC_USED VLC_MALLOC
466
static inline char *var_CreateGetString( vlc_object_t *p_obj,
467
                                           const char *psz_name )
468
{
469 470
    var_Create( p_obj, psz_name, VLC_VAR_STRING | VLC_VAR_DOINHERIT );
    return var_GetString( p_obj, psz_name );
471
}
472

473
VLC_USED VLC_MALLOC
474
static inline char *var_CreateGetNonEmptyString( vlc_object_t *p_obj,
475 476
                                                   const char *psz_name )
{
477 478
    var_Create( p_obj, psz_name, VLC_VAR_STRING | VLC_VAR_DOINHERIT );
    return var_GetNonEmptyString( p_obj, psz_name );
479 480
}

481 482 483 484 485 486
/**
 * Create an address variable with inherit and get its value.
 *
 * \param p_obj The object that holds the variable
 * \param psz_name The name of the variable
 */
487
VLC_USED
488
static inline void *var_CreateGetAddress( vlc_object_t *p_obj,
489 490
                                           const char *psz_name )
{
491 492
    var_Create( p_obj, psz_name, VLC_VAR_ADDRESS | VLC_VAR_DOINHERIT );
    return var_GetAddress( p_obj, psz_name );
493 494
}

495 496 497 498 499 500
#define var_CreateGetInteger(a,b)   var_CreateGetInteger( VLC_OBJECT(a),b)
#define var_CreateGetBool(a,b)   var_CreateGetBool( VLC_OBJECT(a),b)
#define var_CreateGetFloat(a,b)   var_CreateGetFloat( VLC_OBJECT(a),b)
#define var_CreateGetString(a,b)   var_CreateGetString( VLC_OBJECT(a),b)
#define var_CreateGetNonEmptyString(a,b)   var_CreateGetNonEmptyString( VLC_OBJECT(a),b)
#define var_CreateGetAddress(a,b)  var_CreateGetAddress( VLC_OBJECT(a),b)
501

502 503 504 505 506 507
/**
 * Create a integer command variable with inherit and get its value.
 *
 * \param p_obj The object that holds the variable
 * \param psz_name The name of the variable
 */
508
VLC_USED
509
static inline int64_t var_CreateGetIntegerCommand( vlc_object_t *p_obj, const char *psz_name )
510
{
511
    var_Create( p_obj, psz_name, VLC_VAR_INTEGER | VLC_VAR_DOINHERIT
512
                                   | VLC_VAR_ISCOMMAND );
513
    return var_GetInteger( p_obj, psz_name );
514 515 516 517 518 519 520 521
}

/**
 * Create a boolean command variable with inherit and get its value.
 *
 * \param p_obj The object that holds the variable
 * \param psz_name The name of the variable
 */
522
VLC_USED
523
static inline bool var_CreateGetBoolCommand( vlc_object_t *p_obj, const char *psz_name )
524
{
525
    var_Create( p_obj, psz_name, VLC_VAR_BOOL | VLC_VAR_DOINHERIT
526
                                   | VLC_VAR_ISCOMMAND );
527
    return var_GetBool( p_obj, psz_name );
528 529 530 531 532 533 534 535
}

/**
 * Create a float command variable with inherit and get its value.
 *
 * \param p_obj The object that holds the variable
 * \param psz_name The name of the variable
 */
536
VLC_USED
537
static inline float var_CreateGetFloatCommand( vlc_object_t *p_obj, const char *psz_name )
538
{
539
    var_Create( p_obj, psz_name, VLC_VAR_FLOAT | VLC_VAR_DOINHERIT
540
                                   | VLC_VAR_ISCOMMAND );
541
    return var_GetFloat( p_obj, psz_name );
542 543 544 545 546 547 548 549
}

/**
 * Create a string command variable with inherit and get its value.
 *
 * \param p_obj The object that holds the variable
 * \param psz_name The name of the variable
 */
550
VLC_USED VLC_MALLOC
551
static inline char *var_CreateGetStringCommand( vlc_object_t *p_obj,
552 553
                                           const char *psz_name )
{
554
    var_Create( p_obj, psz_name, VLC_VAR_STRING | VLC_VAR_DOINHERIT
555
                                   | VLC_VAR_ISCOMMAND );
556
    return var_GetString( p_obj, psz_name );
557 558
}

559
VLC_USED VLC_MALLOC
560
static inline char *var_CreateGetNonEmptyStringCommand( vlc_object_t *p_obj,
561 562
                                                   const char *psz_name )
{
563
    var_Create( p_obj, psz_name, VLC_VAR_STRING | VLC_VAR_DOINHERIT
564
                                   | VLC_VAR_ISCOMMAND );
565
    return var_GetNonEmptyString( p_obj, psz_name );
566 567
}

568 569 570 571 572
#define var_CreateGetIntegerCommand(a,b)   var_CreateGetIntegerCommand( VLC_OBJECT(a),b)
#define var_CreateGetBoolCommand(a,b)   var_CreateGetBoolCommand( VLC_OBJECT(a),b)
#define var_CreateGetFloatCommand(a,b)   var_CreateGetFloatCommand( VLC_OBJECT(a),b)
#define var_CreateGetStringCommand(a,b)   var_CreateGetStringCommand( VLC_OBJECT(a),b)
#define var_CreateGetNonEmptyStringCommand(a,b)   var_CreateGetNonEmptyStringCommand( VLC_OBJECT(a),b)
573

574
VLC_USED
575
static inline int var_CountChoices( vlc_object_t *p_obj, const char *psz_name )
576 577
{
    vlc_value_t count;
578
    if( var_Change( p_obj, psz_name, VLC_VAR_CHOICESCOUNT, &count, NULL ) )
579 580 581
        return 0;
    return count.i_int;
}
582
#define var_CountChoices(a,b) var_CountChoices( VLC_OBJECT(a),b)
583

584

585
static inline bool var_ToggleBool( vlc_object_t *p_obj, const char *psz_name )
586 587
{
    vlc_value_t val;
588 589
    if( var_GetAndSet( p_obj, psz_name, VLC_VAR_BOOL_TOGGLE, &val ) )
        return false;
590
    return val.b_bool;
591
}
592
#define var_ToggleBool(a,b) var_ToggleBool( VLC_OBJECT(a),b )
593

Laurent Aimar's avatar
Laurent Aimar committed
594

595
VLC_USED
Laurent Aimar's avatar
Laurent Aimar committed
596 597 598 599 600 601 602 603 604 605
static inline bool var_InheritBool( vlc_object_t *obj, const char *name )
{
    vlc_value_t val;

    if( var_Inherit( obj, name, VLC_VAR_BOOL, &val ) )
        val.b_bool = false;
    return val.b_bool;
}
#define var_InheritBool(o, n) var_InheritBool(VLC_OBJECT(o), n)

606
VLC_USED
607
static inline int64_t var_InheritInteger( vlc_object_t *obj, const char *name )
608 609 610 611 612 613 614 615 616
{
    vlc_value_t val;

    if( var_Inherit( obj, name, VLC_VAR_INTEGER, &val ) )
        val.i_int = 0;
    return val.i_int;
}
#define var_InheritInteger(o, n) var_InheritInteger(VLC_OBJECT(o), n)

617
VLC_USED
618 619 620 621 622 623 624 625 626 627
static inline float var_InheritFloat( vlc_object_t *obj, const char *name )
{
    vlc_value_t val;

    if( var_Inherit( obj, name, VLC_VAR_FLOAT, &val ) )
        val.f_float = 0.;
    return val.f_float;
}
#define var_InheritFloat(o, n) var_InheritFloat(VLC_OBJECT(o), n)

628
VLC_USED VLC_MALLOC
629 630 631 632 633 634 635 636 637 638 639 640 641 642 643
static inline char *var_InheritString( vlc_object_t *obj, const char *name )
{
    vlc_value_t val;

    if( var_Inherit( obj, name, VLC_VAR_STRING, &val ) )
        val.psz_string = NULL;
    else if( val.psz_string && !*val.psz_string )
    {
        free( val.psz_string );
        val.psz_string = NULL;
    }
    return val.psz_string;
}
#define var_InheritString(o, n) var_InheritString(VLC_OBJECT(o), n)

644
VLC_USED
645 646 647 648 649 650 651 652
static inline void *var_InheritAddress( vlc_object_t *obj, const char *name )
{
    vlc_value_t val;

    if( var_Inherit( obj, name, VLC_VAR_ADDRESS, &val ) )
        val.p_address = NULL;
    return val.p_address;
}
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
653
#define var_InheritAddress(o, n) var_InheritAddress(VLC_OBJECT(o), n)
654

655
VLC_API int var_InheritURational( vlc_object_t *, unsigned *num, unsigned *den, const char *var );
656 657
#define var_InheritURational(a,b,c,d) var_InheritURational(VLC_OBJECT(a), b, c, d)

658 659 660 661 662 663 664
#define var_GetInteger(a,b)   var_GetInteger( VLC_OBJECT(a),b)
#define var_GetBool(a,b)   var_GetBool( VLC_OBJECT(a),b)
#define var_GetFloat(a,b)   var_GetFloat( VLC_OBJECT(a),b)
#define var_GetString(a,b)   var_GetString( VLC_OBJECT(a),b)
#define var_GetNonEmptyString(a,b)   var_GetNonEmptyString( VLC_OBJECT(a),b)
#define var_GetAddress(a,b)  var_GetAddress( VLC_OBJECT(a),b)

665
VLC_API int var_LocationParse(vlc_object_t *, const char *mrl, const char *prefix);
666 667
#define var_LocationParse(o, m, p) var_LocationParse(VLC_OBJECT(o), m, p)

Sigmund Augdal Helberg's avatar
Sigmund Augdal Helberg committed
668 669 670
/**
 * @}
 */
671
#endif /*  _VLC_VARIABLES_H */