git.sesse.net Git - vlc/blob - src/playlist/item-ext.c

   1 /*****************************************************************************
   2  * item-ext.c : Playlist item management functions (act on the playlist)
   3  *****************************************************************************
   4  * Copyright (C) 1999-2004 VideoLAN (Centrale Réseaux) and its contributors
   5  * $Id$
   6  *
   7  * Authors: Samuel Hocevar <sam@zoy.org>
   8  *          Clément Stenac <zorglub@videolan.org>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23  *****************************************************************************/
  24 #include <stdlib.h>                                      /* free(), strtol() */
  25 #include <stdio.h>                                              /* sprintf() */
  26 #include <string.h>                                            /* strerror() */
  27
  28 #include <vlc/vlc.h>
  29 #include <vlc/input.h>
  30
  31 #include "vlc_playlist.h"
  32
  33 /***************************************************************************
  34  * Item creation/addition functions
  35  ***************************************************************************/
  36
  37 /**
  38  * Add a MRL into the playlist, duration and options given
  39  *
  40  * \param p_playlist the playlist to add into
  41  * \param psz_uri the mrl to add to the playlist
  42  * \param psz_name a text giving a name or description of this item
  43  * \param i_mode the mode used when adding
  44  * \param i_pos the position in the playlist where to add. If this is
  45  *        PLAYLIST_END the item will be added at the end of the playlist
  46  *        regardless of it's size
  47  * \param i_duration length of the item in milliseconds.
  48  * \param ppsz_options an array of options
  49  * \param i_options the number of options
  50  * \return The id of the playlist item
  51 */
  52 int playlist_AddExt( playlist_t *p_playlist, const char * psz_uri,
  53                      const char *psz_name, int i_mode, int i_pos,
  54                      mtime_t i_duration, const char **ppsz_options,
  55                      int i_options )
  56 {
  57     playlist_item_t *p_item;
  58     p_item = playlist_ItemNew( p_playlist , psz_uri, psz_name );
  59
  60     if( p_item == NULL )
  61     {
  62         msg_Err( p_playlist, "unable to add item to playlist" );
  63         return -1;
  64     }
  65
  66     p_item->input.i_duration = i_duration;
  67     p_item->input.i_options = i_options;
  68     p_item->input.ppsz_options = NULL;
  69
  70     for( p_item->input.i_options = 0; p_item->input.i_options < i_options;
  71          p_item->input.i_options++ )
  72     {
  73         if( !p_item->input.i_options )
  74         {
  75             p_item->input.ppsz_options = malloc( i_options * sizeof(char *) );
  76             if( !p_item->input.ppsz_options ) break;
  77         }
  78
  79         p_item->input.ppsz_options[p_item->input.i_options] =
  80             strdup( ppsz_options[p_item->input.i_options] );
  81     }
  82
  83     return playlist_AddItem( p_playlist, p_item, i_mode, i_pos );
  84 }
  85
  86 /**
  87  * Add a MRL into the playlist.
  88  *
  89  * \param p_playlist the playlist to add into
  90  * \param psz_uri the mrl to add to the playlist
  91  * \param psz_name a text giving a name or description of this item
  92  * \param i_mode the mode used when adding
  93  * \param i_pos the position in the playlist where to add. If this is
  94  *        PLAYLIST_END the item will be added at the end of the playlist
  95  *        regardless of it's size
  96  * \return The id of the playlist item
  97 */
  98 int playlist_Add( playlist_t *p_playlist, const char *psz_uri,
  99                   const char *psz_name, int i_mode, int i_pos )
 100 {
 101     return playlist_AddExt( p_playlist, psz_uri, psz_name, i_mode, i_pos,
 102                             -1, NULL, 0 );
 103 }
 104
 105 /**
 106  * Add a playlist item into a playlist
 107  *
 108  * \param p_playlist the playlist to insert into
 109  * \param p_item the playlist item to insert
 110  * \param i_mode the mode used when adding
 111  * \param i_pos the possition in the playlist where to add. If this is
 112  *        PLAYLIST_END the item will be added at the end of the playlist
 113  *        regardless of it's size
 114  * \return The id of the playlist item
 115  */
 116 int playlist_AddItem( playlist_t *p_playlist, playlist_item_t *p_item,
 117                       int i_mode, int i_pos)
 118 {
 119     vlc_value_t val;
 120     vlc_bool_t b_end = VLC_FALSE;
 121     playlist_view_t *p_view = NULL;
 122
 123     playlist_add_t *p_add = (playlist_add_t *)malloc(sizeof( playlist_add_t));
 124
 125     vlc_mutex_lock( &p_playlist->object_lock );
 126
 127     /*
 128      * CHECK_INSERT : checks if the item is already enqued before
 129      * enqueing it
 130      */
 131
 132     /* That should not change */
 133     if ( i_mode & PLAYLIST_CHECK_INSERT )
 134     {
 135          int j;
 136
 137         if ( p_playlist->pp_items )
 138         {
 139             for ( j = 0; j < p_playlist->i_size; j++ )
 140             {
 141                 if ( !strcmp( p_playlist->pp_items[j]->input.psz_uri,
 142                                p_item->input.psz_uri ) )
 143                 {
 144                     playlist_ItemDelete( p_item );
 145                     vlc_mutex_unlock( &p_playlist->object_lock );
 146                     return -1;
 147                 }
 148              }
 149          }
 150          i_mode &= ~PLAYLIST_CHECK_INSERT;
 151          i_mode |= PLAYLIST_APPEND;
 152     }
 153
 154     msg_Dbg( p_playlist, "adding playlist item `%s' ( %s )",
 155              p_item->input.psz_name, p_item->input.psz_uri );
 156
 157     p_item->input.i_id = ++p_playlist->i_last_id;
 158
 159     /* Do a few boundary checks and allocate space for the item */
 160     if( i_pos == PLAYLIST_END )
 161     {
 162         b_end = VLC_TRUE;
 163         if( i_mode & PLAYLIST_INSERT )
 164         {
 165             i_mode &= ~PLAYLIST_INSERT;
 166             i_mode |= PLAYLIST_APPEND;
 167         }
 168
 169         i_pos = p_playlist->i_size - 1;
 170     }
 171
 172     if( !(i_mode & PLAYLIST_REPLACE)
 173          || i_pos < 0 || i_pos >= p_playlist->i_size )
 174     {
 175         /* Additional boundary checks */
 176         if( i_mode & PLAYLIST_APPEND )
 177         {
 178             i_pos++;
 179         }
 180
 181         if( i_pos < 0 )
 182         {
 183             i_pos = 0;
 184         }
 185         else if( i_pos > p_playlist->i_size )
 186         {
 187             i_pos = p_playlist->i_size;
 188         }
 189
 190         INSERT_ELEM( p_playlist->pp_items, p_playlist->i_size, i_pos, p_item );
 191         INSERT_ELEM( p_playlist->pp_all_items, p_playlist->i_all_size,
 192                      p_playlist->i_all_size, p_item );
 193         p_playlist->i_enabled ++;
 194
 195         /* We update the ALL view directly */
 196         playlist_ViewUpdate( p_playlist, VIEW_ALL );
 197
 198         /* Add the item to the General category */
 199         if( b_end == VLC_TRUE )
 200         {
 201             playlist_NodeAppend( p_playlist, VIEW_CATEGORY, p_item,
 202                                  p_playlist->p_general );
 203             p_add->i_item = p_item->input.i_id;
 204             p_add->i_node = p_playlist->p_general->input.i_id;
 205             p_add->i_view = VIEW_CATEGORY;
 206             val.p_address = p_add;
 207             var_Set( p_playlist, "item-append", val );
 208         }
 209         else
 210         {
 211             playlist_NodeInsert( p_playlist, VIEW_CATEGORY, p_item,
 212                                  p_playlist->p_general, i_pos );
 213         }
 214
 215
 216         p_view = playlist_ViewFind( p_playlist, VIEW_ALL );
 217         playlist_ItemAddParent( p_item, VIEW_ALL, p_view->p_root );
 218
 219         /* FIXME : Update sorted views */
 220
 221         if( p_playlist->i_index >= i_pos )
 222         {
 223             p_playlist->i_index++;
 224         }
 225     }
 226     else
 227     {
 228         msg_Err( p_playlist, "Insert mode not implemented" );
 229     }
 230
 231     if( (i_mode & PLAYLIST_GO ) && p_view )
 232     {
 233         p_playlist->request.b_request = VLC_TRUE;
 234         /* FIXME ... */
 235         p_playlist->request.i_view = VIEW_CATEGORY;
 236         p_playlist->request.p_node = p_view->p_root;
 237         p_playlist->request.p_item = p_item;
 238
 239         if( p_playlist->p_input )
 240         {
 241             input_StopThread( p_playlist->p_input );
 242         }
 243         p_playlist->status.i_status = PLAYLIST_RUNNING;
 244     }
 245
 246     vlc_mutex_unlock( &p_playlist->object_lock );
 247
 248     if( b_end == VLC_FALSE )
 249     {
 250         val.b_bool = VLC_TRUE;
 251         var_Set( p_playlist, "intf-change", val );
 252     }
 253
 254     free( p_add );
 255
 256     return p_item->input.i_id;
 257 }
 258
 259
 260 /**
 261  * Add a playlist item to a given node (in the category view )
 262  *
 263  * \param p_playlist the playlist to insert into
 264  * \param p_item the playlist item to insert
 265  * \param i_view the view for which to add or TODO: ALL_VIEWS
 266  * \param p_parent the parent node
 267  * \param i_mode the mode used when adding
 268  * \param i_pos the possition in the node where to add. If this is
 269  *        PLAYLIST_END the item will be added at the end of the node
 270  ** \return The id of the playlist item
 271  */
 272 int playlist_NodeAddItem( playlist_t *p_playlist, playlist_item_t *p_item,
 273                           int i_view,playlist_item_t *p_parent,
 274                           int i_mode, int i_pos)
 275 {
 276     vlc_value_t val;
 277     int i_position;
 278     playlist_view_t *p_view;
 279
 280     playlist_add_t *p_add = (playlist_add_t *)malloc(sizeof( playlist_add_t));
 281
 282     vlc_mutex_lock( &p_playlist->object_lock );
 283
 284     /* Sanity checks */
 285     if( !p_parent || p_parent->i_children == -1 )
 286     {
 287         msg_Err( p_playlist, "invalid node" );
 288     }
 289
 290     /*
 291      * CHECK_INSERT : checks if the item is already enqued before
 292      * enqueing it
 293      */
 294     if ( i_mode & PLAYLIST_CHECK_INSERT )
 295     {
 296          int j;
 297
 298         if ( p_playlist->pp_items )
 299         {
 300             for ( j = 0; j < p_playlist->i_size; j++ )
 301             {
 302                 if ( !strcmp( p_playlist->pp_items[j]->input.psz_uri,
 303                               p_item->input.psz_uri ) )
 304                 {
 305                     playlist_ItemDelete( p_item );
 306                     vlc_mutex_unlock( &p_playlist->object_lock );
 307                     free( p_add );
 308                     return -1;
 309                 }
 310             }
 311         }
 312         i_mode &= ~PLAYLIST_CHECK_INSERT;
 313         i_mode |= PLAYLIST_APPEND;
 314     }
 315
 316     msg_Dbg( p_playlist, "adding playlist item `%s' ( %s )",
 317              p_item->input.psz_name, p_item->input.psz_uri );
 318
 319     p_item->input.i_id = ++p_playlist->i_last_id;
 320
 321     /* First, add the item at the right position in the item bank */
 322     /* WHY THAT ? */
 323      //i_position = p_playlist->i_index == -1 ? 0 : p_playlist->i_index;
 324     i_position = p_playlist->i_size ;
 325
 326     INSERT_ELEM( p_playlist->pp_items,
 327                  p_playlist->i_size,
 328                  i_position,
 329                  p_item );
 330     INSERT_ELEM( p_playlist->pp_all_items,
 331                  p_playlist->i_all_size,
 332                  p_playlist->i_all_size,
 333                  p_item );
 334     p_playlist->i_enabled ++;
 335
 336     /* TODO: Handle modes */
 337     playlist_NodeAppend( p_playlist, i_view, p_item, p_parent );
 338
 339     p_add->i_item = p_item->input.i_id;
 340     p_add->i_node = p_parent->input.i_id;
 341     p_add->i_view = i_view;
 342     val.p_address = p_add;
 343     var_Set( p_playlist, "item-append", val );
 344
 345     /* We update the ALL view directly */
 346     p_view = playlist_ViewFind( p_playlist, VIEW_ALL );
 347     playlist_ItemAddParent( p_item, VIEW_ALL, p_view->p_root );
 348     playlist_ViewUpdate( p_playlist, VIEW_ALL );
 349
 350     /* TODO : Update sorted views*/
 351
 352     if( i_mode & PLAYLIST_GO )
 353     {
 354         p_playlist->request.b_request = VLC_TRUE;
 355         p_playlist->request.i_view = VIEW_CATEGORY;
 356         p_playlist->request.p_node = p_parent;
 357         p_playlist->request.p_item = p_item;
 358         if( p_playlist->p_input )
 359         {
 360             input_StopThread( p_playlist->p_input );
 361         }
 362         p_playlist->status.i_status = PLAYLIST_RUNNING;
 363     }
 364
 365     vlc_mutex_unlock( &p_playlist->object_lock );
 366
 367     val.b_bool = VLC_TRUE;
 368 //    var_Set( p_playlist, "intf-change", val );
 369 //
 370     free( p_add );
 371
 372     return p_item->input.i_id;
 373 }
 374
 375 /***************************************************************************
 376  * Item search functions
 377  ***************************************************************************/
 378
 379 /**
 380  * Search the position of an item by its id
 381  * This function must be entered with the playlist lock
 382  *
 383  * \param p_playlist the playlist
 384  * \param i_id the id to find
 385  * \return the position, or VLC_EGENERIC on failure
 386  */
 387 int playlist_GetPositionById( playlist_t * p_playlist , int i_id )
 388 {
 389     int i;
 390     for( i =  0 ; i < p_playlist->i_size ; i++ )
 391     {
 392         if( p_playlist->pp_items[i]->input.i_id == i_id )
 393         {
 394             return i;
 395         }
 396     }
 397     return VLC_EGENERIC;
 398 }
 399
 400
 401 /**
 402  * Search an item by its position
 403  * This function must be entered with the playlist lock
 404  *
 405  * \param p_playlist the playlist
 406  * \param i_pos the position of the item to find
 407  * \return the item, or NULL on failure
 408  */
 409 playlist_item_t * playlist_ItemGetByPos( playlist_t * p_playlist , int i_pos )
 410 {
 411     if( i_pos >= 0 && i_pos < p_playlist->i_size)
 412     {
 413         return p_playlist->pp_items[i_pos];
 414     }
 415     else if( p_playlist->i_size > 0)
 416     {
 417         return p_playlist->pp_items[p_playlist->i_index];
 418     }
 419     else
 420     {
 421         return NULL;
 422     }
 423 }
 424
 425 playlist_item_t *playlist_LockItemGetByPos( playlist_t *p_playlist, int i_pos )
 426 {
 427     playlist_item_t *p_ret;
 428     vlc_mutex_lock( &p_playlist->object_lock );
 429     p_ret = playlist_ItemGetByPos( p_playlist, i_pos );
 430     vlc_mutex_unlock( &p_playlist->object_lock );
 431     return p_ret;
 432 }
 433
 434 /**
 435  * Search an item by its id
 436  *
 437  * \param p_playlist the playlist
 438  * \param i_id the id to find
 439  * \return the item, or NULL on failure
 440  */
 441 playlist_item_t * playlist_ItemGetById( playlist_t * p_playlist , int i_id )
 442 {
 443     int i, i_top, i_bottom;
 444     i_bottom = 0; i_top = p_playlist->i_all_size - 1;
 445     i = i_top / 2;
 446     while( p_playlist->pp_all_items[i]->input.i_id != i_id &&
 447            i_top > i_bottom )
 448     {
 449         if( p_playlist->pp_all_items[i]->input.i_id < i_id )
 450         {
 451             i_bottom = i + 1;
 452         }
 453         else
 454         {
 455             i_top = i - 1;
 456         }
 457         i = i_bottom + ( i_top - i_bottom ) / 2;
 458     }
 459     if( p_playlist->pp_all_items[i]->input.i_id == i_id )
 460     {
 461         return p_playlist->pp_all_items[i];
 462     }
 463     return NULL;
 464 }
 465
 466 playlist_item_t *playlist_LockItemGetById( playlist_t *p_playlist, int i_id)
 467 {
 468     playlist_item_t *p_ret;
 469     vlc_mutex_lock( &p_playlist->object_lock );
 470     p_ret = playlist_ItemGetById( p_playlist, i_id );
 471     vlc_mutex_unlock( &p_playlist->object_lock );
 472     return p_ret;
 473 }
 474
 475 /**
 476  * Search an item by its input_item_t
 477  *
 478  * \param p_playlist the playlist
 479  * \param p_item the input_item_t to find
 480  * \return the item, or NULL on failure
 481  */
 482 playlist_item_t * playlist_ItemGetByInput( playlist_t * p_playlist ,
 483                                            input_item_t *p_item )
 484 {
 485     int i;
 486     if( &p_playlist->status.p_item->input == p_item )
 487     {
 488         return p_playlist->status.p_item;
 489     }
 490
 491     for( i =  0 ; i < p_playlist->i_size ; i++ )
 492     {
 493         if( &p_playlist->pp_items[i]->input == p_item )
 494         {
 495             return p_playlist->pp_items[i];
 496         }
 497     }
 498     return NULL;
 499 }
 500
 501 playlist_item_t *playlist_LockItemGetByInput( playlist_t *p_playlist,
 502                                                input_item_t *p_item )
 503 {
 504     playlist_item_t *p_ret;
 505     vlc_mutex_lock( &p_playlist->object_lock );
 506     p_ret = playlist_ItemGetByInput( p_playlist, p_item );
 507     vlc_mutex_unlock( &p_playlist->object_lock );
 508     return p_ret;
 509 }
 510
 511
 512 /***********************************************************************
 513  * Misc functions
 514  ***********************************************************************/
 515
 516 /**
 517  * Transform an item to a node
 518  *
 519  * This function must be entered without the playlist lock
 520  *
 521  * \param p_playlist the playlist object
 522  * \param p_item the item to transform
 523  * \return nothing
 524  */
 525 int playlist_ItemToNode( playlist_t *p_playlist,playlist_item_t *p_item )
 526 {
 527     int i = 0;
 528     if( p_item->i_children == -1 )
 529     {
 530         p_item->i_children = 0;
 531     }
 532
 533     /* Remove it from the array of available items */
 534     for( i = 0 ; i < p_playlist->i_size ; i++ )
 535     {
 536         if( p_item == p_playlist->pp_items[i] )
 537         {
 538             REMOVE_ELEM( p_playlist->pp_items, p_playlist->i_size, i );
 539         }
 540     }
 541     var_SetInteger( p_playlist, "item-change", p_item->input.i_id );
 542
 543     return VLC_SUCCESS;
 544 }
 545
 546 int playlist_LockItemToNode( playlist_t *p_playlist, playlist_item_t *p_item )
 547 {
 548     int i_ret;
 549     vlc_mutex_lock( &p_playlist->object_lock );
 550     i_ret = playlist_ItemToNode( p_playlist, p_item );
 551     vlc_mutex_unlock( &p_playlist->object_lock );
 552     return i_ret;
 553 }
 554
 555 /**
 556  * Replaces an item with another one
 557  * This function must be entered without the playlist lock
 558  *
 559  * \see playlist_Replace
 560  */
 561 int playlist_LockReplace( playlist_t *p_playlist,
 562                              playlist_item_t *p_olditem,
 563                              input_item_t *p_new )
 564 {
 565     int i_ret;
 566     vlc_mutex_lock( &p_playlist->object_lock );
 567     i_ret = playlist_Replace( p_playlist, p_olditem, p_new );
 568     vlc_mutex_unlock( &p_playlist->object_lock );
 569     return i_ret;
 570 }
 571
 572 /**
 573  * Replaces an item with another one
 574  * This function must be entered with the playlist lock:
 575  *
 576  * \param p_playlist the playlist
 577  * \param p_olditem the item to replace
 578  * \param p_new the new input_item
 579  * \return VLC_SUCCESS or an error
 580  */
 581 int playlist_Replace( playlist_t *p_playlist, playlist_item_t *p_olditem,
 582                        input_item_t *p_new )
 583 {
 584     int i;
 585     int j;
 586
 587     if( p_olditem->i_children != -1 )
 588     {
 589         msg_Err( p_playlist, "playlist_Replace can only be used on leafs");
 590         return VLC_EGENERIC;
 591     }
 592
 593     p_olditem->i_nb_played = 0;
 594     memcpy( &p_olditem->input, p_new, sizeof( input_item_t ) );
 595
 596     p_olditem->i_nb_played = 0;
 597
 598     for( i = 0 ; i< p_olditem->i_parents ; i++ )
 599     {
 600         playlist_item_t *p_parent = p_olditem->pp_parents[i]->p_parent;
 601
 602         for( j = 0 ; j< p_parent->i_children ; i++ )
 603         {
 604             if( p_parent->pp_children[j] == p_olditem )
 605             {
 606                 p_parent->i_serial++;
 607             }
 608         }
 609     }
 610     return VLC_SUCCESS;
 611 }
 612
 613 /**
 614  * Deletes an item from a playlist.
 615  *
 616  * This function must be entered without the playlist lock
 617  *
 618  * \param p_playlist the playlist to remove from.
 619  * \param i_id the identifier of the item to delete
 620  * \return returns VLC_SUCCESS or an error
 621  */
 622 int playlist_Delete( playlist_t * p_playlist, int i_id )
 623 {
 624     int i, i_top, i_bottom;
 625     int i_pos;
 626     vlc_bool_t b_flag = VLC_FALSE;
 627
 628     playlist_item_t *p_item = playlist_ItemGetById( p_playlist, i_id );
 629
 630     if( p_item == NULL )
 631     {
 632         return VLC_EGENERIC;
 633     }
 634     if( p_item->i_children > -1 )
 635     {
 636         return playlist_NodeDelete( p_playlist, p_item, VLC_TRUE, VLC_FALSE );
 637     }
 638
 639     var_SetInteger( p_playlist, "item-deleted", i_id );
 640
 641     i_bottom = 0; i_top = p_playlist->i_all_size - 1;
 642     i = i_top / 2;
 643     while( p_playlist->pp_all_items[i]->input.i_id != i_id &&
 644            i_top > i_bottom )
 645     {
 646         if( p_playlist->pp_all_items[i]->input.i_id < i_id )
 647         {
 648             i_bottom = i + 1;
 649         }
 650         else
 651         {
 652             i_top = i - 1;
 653         }
 654         i = i_bottom + ( i_top - i_bottom ) / 2;
 655     }
 656     if( p_playlist->pp_all_items[i]->input.i_id == i_id )
 657     {
 658         REMOVE_ELEM( p_playlist->pp_all_items, p_playlist->i_all_size, i );
 659     }
 660
 661     /* Check if it is the current item */
 662     if( p_playlist->status.p_item == p_item )
 663     {
 664         /* Hack we don't call playlist_Control for lock reasons */
 665         p_playlist->status.i_status = PLAYLIST_STOPPED;
 666         p_playlist->request.b_request = VLC_TRUE;
 667         p_playlist->request.p_item = NULL;
 668         msg_Info( p_playlist, "stopping playback" );
 669         b_flag = VLC_TRUE;
 670     }
 671
 672     /* Get position and update index if needed */
 673     i_pos = playlist_GetPositionById( p_playlist, i_id );
 674
 675     if( i_pos >= 0 && i_pos <= p_playlist->i_index )
 676     {
 677         p_playlist->i_index--;
 678     }
 679
 680     msg_Dbg( p_playlist, "deleting playlist item `%s'",
 681                           p_item->input.psz_name );
 682
 683     /* Remove the item from all its parent nodes */
 684     for ( i= 0 ; i < p_item->i_parents ; i++ )
 685     {
 686         playlist_NodeRemoveItem( p_playlist, p_item,
 687                                  p_item->pp_parents[i]->p_parent );
 688         if( p_item->pp_parents[i]->i_view == VIEW_ALL )
 689         {
 690             p_playlist->i_size--;
 691         }
 692     }
 693
 694     /* TODO : Update views */
 695
 696     if( b_flag == VLC_FALSE )
 697         playlist_ItemDelete( p_item );
 698     else
 699         p_item->i_flags |= PLAYLIST_REMOVE_FLAG;
 700
 701     return VLC_SUCCESS;
 702 }
 703
 704 int playlist_LockDelete( playlist_t * p_playlist, int i_id )
 705 {
 706     int i_ret;
 707     vlc_mutex_lock( &p_playlist->object_lock );
 708     i_ret = playlist_Delete( p_playlist, i_id );
 709     vlc_mutex_unlock( &p_playlist->object_lock );
 710     return i_ret;
 711 }
 712
 713 /**
 714  * Clear all playlist items
 715  *
 716  * \param p_playlist the playlist to be cleared.
 717  * \return returns 0
 718  */
 719 int playlist_Clear( playlist_t * p_playlist )
 720 {
 721     int i;
 722     for( i = p_playlist->i_size; i > 0 ; i-- )
 723     {
 724         playlist_Delete( p_playlist, p_playlist->pp_items[0]->input.i_id );
 725     }
 726     for( i = 0 ; i< p_playlist->i_views; i++ )
 727     {
 728         playlist_ViewEmpty( p_playlist, i, VLC_TRUE );
 729     }
 730     return VLC_SUCCESS;
 731 }
 732
 733 int playlist_LockClear( playlist_t *p_playlist )
 734 {
 735     int i_ret;
 736     vlc_mutex_lock( &p_playlist->object_lock );
 737     i_ret = playlist_Clear( p_playlist );
 738     vlc_mutex_unlock( &p_playlist->object_lock );
 739     return i_ret;
 740 }
 741
 742
 743 /**
 744  * Disables a playlist item
 745  *
 746  * \param p_playlist the playlist to disable from.
 747  * \param i_pos the position of the item to disable
 748  * \return returns 0
 749  */
 750 int playlist_Disable( playlist_t * p_playlist, playlist_item_t *p_item )
 751 {
 752     if( !p_item ) return VLC_EGENERIC;
 753
 754     msg_Dbg( p_playlist, "disabling playlist item `%s'",
 755                    p_item->input.psz_name );
 756
 757     if( p_item->i_flags & PLAYLIST_ENA_FLAG )
 758     {
 759         p_playlist->i_enabled--;
 760     }
 761     p_item->i_flags &= ~PLAYLIST_ENA_FLAG;
 762
 763     var_SetInteger( p_playlist, "item-change", p_item->input.i_id );
 764     return VLC_SUCCESS;
 765 }
 766
 767 /**
 768  * Enables a playlist item
 769  *
 770  * \param p_playlist the playlist to enable from.
 771  * \param i_pos the position of the item to enable
 772  * \return returns 0
 773  */
 774 int playlist_Enable( playlist_t * p_playlist, playlist_item_t *p_item )
 775 {
 776     if( !p_item ) return VLC_EGENERIC;
 777
 778     msg_Dbg( p_playlist, "enabling playlist item `%s'",
 779                    p_item->input.psz_name );
 780
 781     if( p_item->i_flags & ~PLAYLIST_ENA_FLAG )
 782     {
 783         p_playlist->i_enabled++;
 784     }
 785     p_item->i_flags |= PLAYLIST_ENA_FLAG;
 786
 787     var_SetInteger( p_playlist, "item-change", p_item->input.i_id );
 788     return VLC_SUCCESS;
 789 }
 790
 791 /**
 792  * Move an item in a playlist
 793  *
 794  * This function must be entered without the playlist lock
 795  *
 796  * Move the item in the playlist with position i_pos before the current item
 797  * at position i_newpos.
 798  * \param p_playlist the playlist to move items in
 799  * \param i_pos the position of the item to move
 800  * \param i_newpos the position of the item that will be behind the moved item
 801  *        after the move
 802  * \return returns VLC_SUCCESS
 803  */
 804 int playlist_Move( playlist_t * p_playlist, int i_pos, int i_newpos )
 805 {
 806     vlc_value_t val;
 807     vlc_mutex_lock( &p_playlist->object_lock );
 808
 809     /* take into account that our own row disappears. */
 810     if( i_pos < i_newpos ) i_newpos--;
 811
 812     if( i_pos >= 0 && i_newpos >=0 && i_pos <= p_playlist->i_size &&
 813         i_newpos <= p_playlist->i_size )
 814     {
 815         playlist_item_t * temp;
 816
 817         msg_Dbg( p_playlist, "moving playlist item `%s' (%i -> %i)",
 818                  p_playlist->pp_items[i_pos]->input.psz_name, i_pos, i_newpos);
 819
 820         if( i_pos == p_playlist->i_index )
 821         {
 822             p_playlist->i_index = i_newpos;
 823         }
 824         else if( i_pos > p_playlist->i_index &&
 825                  i_newpos <= p_playlist->i_index )
 826         {
 827             p_playlist->i_index++;
 828         }
 829         else if( i_pos < p_playlist->i_index &&
 830                  i_newpos >= p_playlist->i_index )
 831         {
 832             p_playlist->i_index--;
 833         }
 834
 835         if ( i_pos < i_newpos )
 836         {
 837             temp = p_playlist->pp_items[i_pos];
 838             while ( i_pos < i_newpos )
 839             {
 840                 p_playlist->pp_items[i_pos] = p_playlist->pp_items[i_pos+1];
 841                 i_pos++;
 842             }
 843             p_playlist->pp_items[i_newpos] = temp;
 844         }
 845         else if ( i_pos > i_newpos )
 846         {
 847             temp = p_playlist->pp_items[i_pos];
 848             while ( i_pos > i_newpos )
 849             {
 850                 p_playlist->pp_items[i_pos] = p_playlist->pp_items[i_pos-1];
 851                 i_pos--;
 852             }
 853             p_playlist->pp_items[i_newpos] = temp;
 854         }
 855     }
 856
 857     vlc_mutex_unlock( &p_playlist->object_lock );
 858
 859     val.b_bool = VLC_TRUE;
 860     var_Set( p_playlist, "intf-change", val );
 861
 862     return VLC_SUCCESS;
 863 }
 864
 865 /**
 866  * Moves an item
 867  *
 868  * \param p_playlist the playlist
 869  * \param p_item the item to move
 870  * \param p_node the new parent of the item
 871  * \param i_newpos the new position under this new parent
 872  * \param i_view the view in which the move must be done or ALL_VIEWS
 873  * \return VLC_SUCCESS or an error
 874  */
 875 int playlist_TreeMove( playlist_t * p_playlist, playlist_item_t *p_item,
 876                        playlist_item_t *p_node, int i_newpos, int i_view )
 877 {
 878     int i;
 879     playlist_item_t *p_detach = NULL;
 880 #if 0
 881     if( i_view == ALL_VIEWS )
 882     {
 883         for( i = 0 ; i < p_playlist->i_views; i++ )
 884         {
 885             playlist_TreeMove( p_playlist, p_item, p_node, i_newpos,
 886                                p_playlist->pp_views[i] );
 887         }
 888     }
 889 #endif
 890
 891     /* Find the parent */
 892     for( i = 0 ; i< p_item->i_parents; i++ )
 893     {
 894         if( p_item->pp_parents[i]->i_view == i_view )
 895         {
 896             p_detach = p_item->pp_parents[i]->p_parent;
 897             break;
 898         }
 899     }
 900     if( p_detach == NULL )
 901     {
 902         msg_Err( p_playlist, "item not found in view %i", i_view );
 903         return VLC_EGENERIC;
 904     }
 905
 906     /* Detach from the parent */
 907 //    playlist_NodeDetach( p_detach, p_item );
 908
 909     /* Attach to new parent */
 910
 911     return VLC_SUCCESS;
 912 }