#include <playlist.h>

Inheritance diagram for playlist_manager:

Data Structures
class	enum_items_callback

Public Member Functions
void	active_playlist_fix ()

bool	activeplaylist_add_items (const pfc::list_base_const_t< metadb_handle_ptr > &data, const bit_array &p_selection)

bool	activeplaylist_add_items_filter (const pfc::list_base_const_t< metadb_handle_ptr > &p_data, bool p_select)

bool	activeplaylist_add_locations (const pfc::list_base_const_t< const char * > &p_urls, bool p_select, HWND p_parentwnd)

void	activeplaylist_clear ()

void	activeplaylist_clear_selection ()

void	activeplaylist_ensure_visible (t_size p_item)

void	activeplaylist_enum_items (enum_items_callback &p_callback, const bit_array &p_mask)

bool	activeplaylist_execute_default_action (t_size p_item)

bool	activeplaylist_find_item (metadb_handle_ptr p_item, t_size &p_result)

void	activeplaylist_get_all_items (pfc::list_base_t< metadb_handle_ptr > &out)

t_size	activeplaylist_get_focus_item ()

bool	activeplaylist_get_focus_item_handle (metadb_handle_ptr &item)

t_size	activeplaylist_get_item_count ()

bool	activeplaylist_get_item_handle (metadb_handle_ptr &item, t_size p_item)

metadb_handle_ptr	activeplaylist_get_item_handle (t_size p_item)

void	activeplaylist_get_items (pfc::list_base_t< metadb_handle_ptr > &out, const bit_array &p_mask)

bool	activeplaylist_get_name (pfc::string_base &p_out)

t_size	activeplaylist_get_selected_count (bit_array const &p_mask)

void	activeplaylist_get_selected_items (pfc::list_base_t< metadb_handle_ptr > &out)

t_size	activeplaylist_get_selection_count (t_size p_max)

void	activeplaylist_get_selection_mask (bit_array_var &out)

t_size	activeplaylist_insert_items (t_size p_base, const pfc::list_base_const_t< metadb_handle_ptr > &data, const bit_array &p_selection)

bool	activeplaylist_insert_items_filter (t_size p_base, const pfc::list_base_const_t< metadb_handle_ptr > &p_data, bool p_select)

bool	activeplaylist_insert_locations (t_size p_base, const pfc::list_base_const_t< const char * > &p_urls, bool p_select, HWND p_parentwnd)

bool	activeplaylist_is_item_selected (t_size p_item)

bool	activeplaylist_is_redo_available ()

bool	activeplaylist_is_undo_available ()

void	activeplaylist_item_format_title (t_size p_item, titleformat_hook p_hook, pfc::string_base &out, const service_ptr_t< titleformat_object > &p_script, titleformat_text_filter p_filter, play_control::t_display_level p_playback_info_level)

t_uint32	activeplaylist_lock_get_filter_mask ()

void	activeplaylist_move_selection (int p_delta)

bool	activeplaylist_redo_restore ()

bool	activeplaylist_remove_items (const bit_array &mask)

void	activeplaylist_remove_selection (bool p_crop=false)

bool	activeplaylist_rename (const char *p_name, t_size p_name_len)

bool	activeplaylist_reorder_items (const t_size *order, t_size count)

bool	activeplaylist_replace_item (t_size p_item, const metadb_handle_ptr &p_new_item)

t_size	activeplaylist_set_focus_by_handle (metadb_handle_ptr p_item)

void	activeplaylist_set_focus_item (t_size p_item)

void	activeplaylist_set_selection (const bit_array &affected, const bit_array &status)

void	activeplaylist_set_selection_single (t_size p_item, bool p_state)

bool	activeplaylist_sort_by_format (const char *spec, bool p_sel_only)

void	activeplaylist_undo_backup ()

bool	activeplaylist_undo_restore ()

virtual t_size	create_playlist (const char *p_name, t_size p_name_length, t_size p_index)=0

t_size	create_playlist_autoname (t_size p_index=~0)

	FB2K_MAKE_SERVICE_INTERFACE_ENTRYPOINT (playlist_manager)

t_size	find_or_create_playlist (const char *p_name, t_size p_name_length=~0)

t_size	find_or_create_playlist_unlocked (const char *p_name, t_size p_name_length=~0)

t_size	find_playlist (const char *p_name, t_size p_name_length=~0)

virtual t_size	get_active_playlist ()=0

bool	get_all_items (pfc::list_base_t< metadb_handle_ptr > &out)

virtual bool	get_playing_item_location (t_size p_playlist, t_size p_index)=0

virtual t_size	get_playing_playlist ()=0

virtual t_size	get_playlist_count ()=0

bool	highlight_playing_item ()

virtual void	modify_callback (class playlist_callback *p_callback, unsigned p_flags)=0

virtual void	modify_callback (class playlist_callback_single *p_callback, unsigned p_flags)=0

virtual void	on_files_deleted_sorted (const pfc::list_base_const_t< const char * > &p_items)=0

virtual void	on_files_moved_sorted (const pfc::list_base_const_t< const char * > &p_from, const pfc::list_base_const_t< const char * > &p_to)=0

virtual t_size	playback_order_get_active ()=0

virtual t_size	playback_order_get_count ()=0

virtual GUID	playback_order_get_guid (t_size p_index)=0

virtual const char *	playback_order_get_name (t_size p_index)=0

virtual void	playback_order_set_active (t_size p_index)=0

void	playlist_activate_delta (int p_delta)

void	playlist_activate_next ()

void	playlist_activate_previous ()

bool	playlist_add_items (t_size playlist, const pfc::list_base_const_t< metadb_handle_ptr > &data, const bit_array &p_selection)

bool	playlist_add_items_filter (t_size p_playlist, const pfc::list_base_const_t< metadb_handle_ptr > &p_data, bool p_select)

bool	playlist_add_locations (t_size p_playlist, const pfc::list_base_const_t< const char * > &p_urls, bool p_select, HWND p_parentwnd)

void	playlist_clear (t_size p_playlist)

void	playlist_clear_selection (t_size p_playlist)

virtual void	playlist_ensure_visible (t_size p_playlist, t_size p_item)=0

virtual void	playlist_enum_items (t_size p_playlist, enum_items_callback &p_callback, const bit_array &p_mask)=0

virtual bool	playlist_execute_default_action (t_size p_playlist, t_size p_item)=0

bool	playlist_find_item (t_size p_playlist, metadb_handle_ptr p_item, t_size &p_result)

bool	playlist_find_item_selected (t_size p_playlist, metadb_handle_ptr p_item, t_size &p_result)

void	playlist_get_all_items (t_size p_playlist, pfc::list_base_t< metadb_handle_ptr > &out)

virtual t_size	playlist_get_focus_item (t_size p_playlist)=0

bool	playlist_get_focus_item_handle (metadb_handle_ptr &p_item, t_size p_playlist)

virtual t_size	playlist_get_item_count (t_size p_playlist)=0

bool	playlist_get_item_handle (metadb_handle_ptr &p_out, t_size p_playlist, t_size p_item)

metadb_handle_ptr	playlist_get_item_handle (t_size playlist, t_size item)

void	playlist_get_items (t_size p_playlist, pfc::list_base_t< metadb_handle_ptr > &out, const bit_array &p_mask)

virtual bool	playlist_get_name (t_size p_playlist, pfc::string_base &p_out)=0

t_size	playlist_get_selected_count (t_size p_playlist, bit_array const &p_mask)

void	playlist_get_selected_items (t_size p_playlist, pfc::list_base_t< metadb_handle_ptr > &out)

t_size	playlist_get_selection_count (t_size p_playlist, t_size p_max)

void	playlist_get_selection_mask (t_size p_playlist, bit_array_var &out)

virtual t_size	playlist_insert_items (t_size p_playlist, t_size p_base, const pfc::list_base_const_t< metadb_handle_ptr > &data, const bit_array &p_selection)=0

bool	playlist_insert_items_filter (t_size p_playlist, t_size p_base, const pfc::list_base_const_t< metadb_handle_ptr > &p_data, bool p_select)

bool	playlist_insert_locations (t_size p_playlist, t_size p_base, const pfc::list_base_const_t< const char * > &p_urls, bool p_select, HWND p_parentwnd)

bool	playlist_is_item_selected (t_size p_playlist, t_size p_item)

virtual bool	playlist_is_redo_available (t_size p_playlist)=0

virtual bool	playlist_is_undo_available (t_size p_playlist)=0

virtual void	playlist_item_format_title (t_size p_playlist, t_size p_item, titleformat_hook p_hook, pfc::string_base &p_out, const service_ptr_t< titleformat_object > &p_script, titleformat_text_filter p_filter, playback_control::t_display_level p_playback_info_level)=0

virtual t_uint32	playlist_lock_get_filter_mask (t_size p_playlist)=0

virtual bool	playlist_lock_install (t_size p_playlist, const service_ptr_t< playlist_lock > &p_lock)=0

virtual bool	playlist_lock_is_present (t_size p_playlist)=0

virtual bool	playlist_lock_query_name (t_size p_playlist, pfc::string_base &p_out)=0

virtual bool	playlist_lock_show_ui (t_size p_playlist)=0

virtual bool	playlist_lock_uninstall (t_size p_playlist, const service_ptr_t< playlist_lock > &p_lock)=0

bool	playlist_move_selection (t_size p_playlist, int p_delta)

virtual bool	playlist_redo_restore (t_size p_playlist)=0

virtual bool	playlist_remove_items (t_size p_playlist, const bit_array &mask)=0

void	playlist_remove_selection (t_size p_playlist, bool p_crop=false)

virtual bool	playlist_rename (t_size p_index, const char *p_name, t_size p_name_length)=0

virtual bool	playlist_reorder_items (t_size p_playlist, const t_size *p_order, t_size p_count)=0

virtual bool	playlist_replace_item (t_size p_playlist, t_size p_item, const metadb_handle_ptr &p_new_item)=0

t_size	playlist_set_focus_by_handle (t_size p_playlist, metadb_handle_ptr p_item)

virtual void	playlist_set_focus_item (t_size p_playlist, t_size p_item)=0

virtual void	playlist_set_selection (t_size p_playlist, const bit_array &p_affected, const bit_array &p_status)=0

void	playlist_set_selection_single (t_size p_playlist, t_size p_item, bool p_state)

virtual bool	playlist_sort_by_format (t_size p_playlist, const char *p_pattern, bool p_sel_only)=0

virtual void	playlist_undo_backup (t_size p_playlist)=0

virtual bool	playlist_undo_restore (t_size p_playlist)=0

bool	playlist_update_content (t_size playlist, metadb_handle_list_cref content, bool bUndoBackup)

virtual void	queue_add_item (metadb_handle_ptr p_item)=0

virtual void	queue_add_item_playlist (t_size p_playlist, t_size p_item)=0

virtual t_size	queue_find_index (t_playback_queue_item const &p_item)=0

void	queue_flush ()

virtual void	queue_get_contents (pfc::list_base_t< t_playback_queue_item > &p_out)=0

virtual t_size	queue_get_count ()=0

bool	queue_is_active ()

virtual void	queue_remove_mask (bit_array const &p_mask)=0

virtual void	register_callback (class playlist_callback *p_callback, unsigned p_flags)=0

virtual void	register_callback (class playlist_callback_single *p_callback, unsigned p_flags)=0

void	remove_items_from_all_playlists (const pfc::list_base_const_t< metadb_handle_ptr > &p_data)

bool	remove_playlist (t_size p_playlist)

bool	remove_playlist_switch (t_size p_playlist)

virtual bool	remove_playlists (const bit_array &p_mask)=0

virtual bool	reorder (const t_size *p_order, t_size p_count)=0

void	reset_playing_playlist ()

virtual void	set_active_playlist (t_size p_index)=0

virtual void	set_playing_playlist (t_size p_index)=0

virtual void	unregister_callback (class playlist_callback *p_callback)=0

virtual void	unregister_callback (class playlist_callback_single *p_callback)=0

Public Member Functions inherited from service_base
template<typename outPtr_t >
bool	cast (outPtr_t &outPtr)

virtual int	service_add_ref ()=0 throw ()

virtual bool	service_query (service_ptr_t< service_base > &p_out, const GUID &p_guid)

template<class T >
bool	service_query_t (service_ptr_t< T > &p_out)

virtual int	service_release ()=0 throw ()

Static Public Member Functions
static void	g_make_selection_move_permutation (t_size *p_output, t_size p_count, const bit_array &p_selection, int p_delta)

Additional Inherited Members
Public Types inherited from service_base
typedef service_base	t_interface

Protected Member Functions inherited from service_base
	service_base ()

	~service_base ()

Detailed Description

This service provides methods for all sorts of playlist interaction.
All playlist_manager methods are valid only from main app thread.
Usage: static_api_ptr_t<playlist_manager>.

Definition at line 74 of file playlist.h.

Member Function Documentation

void playlist_manager::active_playlist_fix ( )

Definition at line 564 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist == pfc_infinite)
     {
         t_size max = get_playlist_count();
         if (max == 0)
         {
             create_playlist_autoname();
         }
         set_active_playlist(0);
     }
 }

bool playlist_manager::activeplaylist_add_items	(	const pfc::list_base_const_t< metadb_handle_ptr > &	data,
		const bit_array &	p_selection
	)

Definition at line 343 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) return playlist_add_items(playlist,data,p_selection);
     else return false;
 }

bool playlist_manager::activeplaylist_add_items_filter	(	const pfc::list_base_const_t< metadb_handle_ptr > &	p_data,
		bool	p_select
	)

Definition at line 386 of file playlist.cpp.

 {
     return activeplaylist_insert_items_filter(pfc_infinite,p_data,p_select);
 }

bool playlist_manager::activeplaylist_add_locations	(	const pfc::list_base_const_t< const char * > &	p_urls,
		bool	p_select,
		HWND	p_parentwnd
	)

Definition at line 395 of file playlist.cpp.

 {
     return activeplaylist_insert_locations(pfc_infinite,p_urls,p_select,p_parentwnd);
 }

void playlist_manager::activeplaylist_clear ( )

Definition at line 281 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) playlist_clear(playlist);
 }

void playlist_manager::activeplaylist_clear_selection ( )

Definition at line 410 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) playlist_clear_selection(playlist);
 }

void playlist_manager::activeplaylist_ensure_visible ( t_size p_item )

Definition at line 209 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) playlist_ensure_visible(playlist,p_item);
 }

void playlist_manager::activeplaylist_enum_items	(	enum_items_callback &	p_callback,
		const bit_array &	p_mask
	)

Definition at line 148 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) playlist_enum_items(playlist,p_callback,p_mask);
 }

bool playlist_manager::activeplaylist_execute_default_action ( t_size p_item )

Definition at line 685 of file playlist.cpp.

                                                                           {
     t_size idx = get_active_playlist();
     if (idx == pfc_infinite) return false;
     else return playlist_execute_default_action(idx,p_item);
 }

bool playlist_manager::activeplaylist_find_item	(	metadb_handle_ptr	p_item,
		t_size &	p_result
	)

Definition at line 843 of file playlist.cpp.

                                                                                           {
     t_size playlist = get_active_playlist();
     if (playlist == pfc_infinite) return false;
     return playlist_find_item(playlist,p_item,p_result);
 }

void playlist_manager::activeplaylist_get_all_items ( pfc::list_base_t< metadb_handle_ptr > & out )

Definition at line 254 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) playlist_get_all_items(playlist,out);
 }

t_size playlist_manager::activeplaylist_get_focus_item ( )

Definition at line 154 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist == pfc_infinite) return pfc_infinite;
     else return playlist_get_focus_item(playlist);
 }

bool playlist_manager::activeplaylist_get_focus_item_handle ( metadb_handle_ptr & item )

Definition at line 489 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) return playlist_get_focus_item_handle(p_out,playlist);
     else return false;
 }

t_size playlist_manager::activeplaylist_get_item_count ( )

Definition at line 141 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist == pfc_infinite) return 0;
     else return playlist_get_item_count(playlist);
 }

bool playlist_manager::activeplaylist_get_item_handle	(	metadb_handle_ptr &	item,
		t_size	p_item
	)

Definition at line 235 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) return playlist_get_item_handle(p_out,playlist,p_item);
     else return false;
 }

metadb_handle_ptr playlist_manager::activeplaylist_get_item_handle ( t_size p_item )

Definition at line 229 of file playlist.cpp.

                                                                                 {
     metadb_handle_ptr temp;
     if (!activeplaylist_get_item_handle(temp, p_item)) throw pfc::exception_invalid_params();
     PFC_ASSERT( temp.is_valid() );
     return temp;
 }

void playlist_manager::activeplaylist_get_items	(	pfc::list_base_t< metadb_handle_ptr > &	out,
		const bit_array &	p_mask
	)

Definition at line 557 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) playlist_get_items(playlist,out,p_mask);
     else out.remove_all();
 }

bool playlist_manager::activeplaylist_get_name ( pfc::string_base & p_out )

Definition at line 161 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist == pfc_infinite) return false;
     else return playlist_get_name(playlist,p_out);
 }

t_size playlist_manager::activeplaylist_get_selected_count ( bit_array const & p_mask )

inline

Definition at line 363 of file playlist.h.

363 {return playlist_get_selected_count(get_active_playlist(),p_mask);}

playlist_manager::playlist_get_selected_count

t_size playlist_get_selected_count(t_size p_playlist, bit_array const &p_mask)

Definition: playlist.cpp:780

playlist_manager::get_active_playlist

virtual t_size get_active_playlist()=0

Retrieves index of active playlist; infinite if no playlist is active.

void playlist_manager::activeplaylist_get_selected_items ( pfc::list_base_t< metadb_handle_ptr > & out )

Definition at line 260 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) playlist_get_selected_items(playlist,out);
 }

t_size playlist_manager::activeplaylist_get_selection_count ( t_size p_max )

Definition at line 475 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) return playlist_get_selection_count(playlist,p_max);
     else return 0;
 }

void playlist_manager::activeplaylist_get_selection_mask ( bit_array_var & out )

Definition at line 248 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) playlist_get_selection_mask(playlist,out);
 }

t_size playlist_manager::activeplaylist_insert_items	(	t_size	p_base,
		const pfc::list_base_const_t< metadb_handle_ptr > &	data,
		const bit_array &	p_selection
	)

Definition at line 202 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) return playlist_insert_items(playlist,p_base,data,p_selection);
     else return pfc_infinite;
 }

bool playlist_manager::activeplaylist_insert_items_filter	(	t_size	p_base,
		const pfc::list_base_const_t< metadb_handle_ptr > &	p_data,
		bool	p_select
	)

Definition at line 359 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) return playlist_insert_items_filter(playlist,p_base,p_data,p_select);
     else return false;
 }

bool playlist_manager::activeplaylist_insert_locations	(	t_size	p_base,
		const pfc::list_base_const_t< const char * > &	p_urls,
		bool	p_select,
		HWND	p_parentwnd
	)

Deprecated:: (since 0.9.3) Use playlist_incoming_item_filter_v2::process_locations_async whenever possible

Definition at line 374 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) return playlist_insert_locations(playlist,p_base,p_urls,p_select,p_parentwnd);
     else return false;
 }

bool playlist_manager::activeplaylist_is_item_selected ( t_size p_item )

Definition at line 222 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) return playlist_is_item_selected(playlist,p_item);
     else return false;
 }

bool playlist_manager::activeplaylist_is_redo_available ( )

Definition at line 645 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist == pfc_infinite) return false;
     else return playlist_is_redo_available(playlist);
 }

bool playlist_manager::activeplaylist_is_undo_available ( )

Definition at line 638 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist == pfc_infinite) return false;
     else return playlist_is_undo_available(playlist);
 }

void playlist_manager::activeplaylist_item_format_title	(	t_size	p_item,
		titleformat_hook *	p_hook,
		pfc::string_base &	out,
		const service_ptr_t< titleformat_object > &	p_script,
		titleformat_text_filter *	p_filter,
		play_control::t_display_level	p_playback_info_level
	)

Definition at line 450 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist == pfc_infinite) out = "NJET";
     else playlist_item_format_title(playlist,p_item,p_hook,out,p_script,p_filter,p_playback_info_level);
 }

t_uint32 playlist_manager::activeplaylist_lock_get_filter_mask ( )

Definition at line 631 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist == pfc_infinite) return ~0;
     else return playlist_lock_get_filter_mask(playlist);
 }

void playlist_manager::activeplaylist_move_selection ( int p_delta )

Definition at line 242 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) playlist_move_selection(playlist,p_delta);
 }

bool playlist_manager::activeplaylist_redo_restore ( )

Definition at line 429 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) return playlist_redo_restore(playlist);
     else return false;
 }

bool playlist_manager::activeplaylist_remove_items ( const bit_array & mask )

Definition at line 182 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) return playlist_remove_items(playlist,mask);
     else return false;
 }

void playlist_manager::activeplaylist_remove_selection ( bool p_crop = false )

Definition at line 444 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) playlist_remove_selection(playlist,p_crop);
 }

bool playlist_manager::activeplaylist_rename	(	const char *	p_name,
		t_size	p_name_len
	)

Definition at line 215 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) return playlist_rename(playlist,p_name,p_name_len);
     else return false;
 }

bool playlist_manager::activeplaylist_reorder_items	(	const t_size *	order,
		t_size	count
	)

Definition at line 169 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) return playlist_reorder_items(playlist,order,count);
     else return false;
 }

bool playlist_manager::activeplaylist_replace_item	(	t_size	p_item,
		const metadb_handle_ptr &	p_new_item
	)

Definition at line 189 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) return playlist_replace_item(playlist,p_item,p_new_item);
     else return false;
 }

t_size playlist_manager::activeplaylist_set_focus_by_handle ( metadb_handle_ptr p_item )

Definition at line 848 of file playlist.cpp.

                                                                                     {
     t_size playlist = get_active_playlist();
     if (playlist == pfc_infinite) return pfc_infinite;
     return playlist_set_focus_by_handle(playlist,p_item);
 }

void playlist_manager::activeplaylist_set_focus_item ( t_size p_item )

Definition at line 196 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) playlist_set_focus_item(playlist,p_item);
 }

void playlist_manager::activeplaylist_set_selection	(	const bit_array &	affected,
		const bit_array &	status
	)

Definition at line 176 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) playlist_set_selection(playlist,affected,status);
 }

void playlist_manager::activeplaylist_set_selection_single	(	t_size	p_item,
		bool	p_state
	)

Definition at line 462 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) playlist_set_selection_single(playlist,p_item,p_state);
 }

bool playlist_manager::activeplaylist_sort_by_format	(	const char *	spec,
		bool	p_sel_only
	)

Definition at line 534 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) return playlist_sort_by_format(playlist,spec,p_sel_only);
     else return false;
 }

void playlist_manager::activeplaylist_undo_backup ( )

Definition at line 416 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) playlist_undo_backup(playlist);
 }

bool playlist_manager::activeplaylist_undo_restore ( )

Definition at line 422 of file playlist.cpp.

 {
     t_size playlist = get_active_playlist();
     if (playlist != pfc_infinite) return playlist_undo_restore(playlist);
     else return false;
 }

virtual t_size playlist_manager::create_playlist	(	const char *	p_name,
		t_size	p_name_length,
		t_size	p_index
	)

pure virtual

Creates a new playlist.

Parameters

p_name	Name of playlist to create; a UTF-8 encoded string.
p_name_length	Length limit of playlist name string, in bytes (actual string may be shorter if null terminator is encountered before). Set this to infinite to use plain null-terminated strings.
p_index	Index at which to insert new playlist; set to infinite to put it at the end of playlist list.

Returns: Actual index of newly inserted playlist, infinite on failure (call from invalid context).

t_size playlist_manager::create_playlist_autoname ( t_size p_index = ~0 )

Definition at line 524 of file playlist.cpp.

                                                                 {   
     static const char new_playlist_text[] = "New Playlist";
     if (find_playlist(new_playlist_text,pfc_infinite) == pfc_infinite) return create_playlist(new_playlist_text,pfc_infinite,p_index);
     for(t_size walk = 2; ; walk++) {
         pfc::string_fixed_t<64> namebuffer;
         namebuffer << new_playlist_text << " (" << walk << ")";
         if (find_playlist(namebuffer,pfc_infinite) == pfc_infinite) return create_playlist(namebuffer,pfc_infinite,p_index);
     }
 }

playlist_manager::FB2K_MAKE_SERVICE_INTERFACE_ENTRYPOINT ( playlist_manager )

t_size playlist_manager::find_or_create_playlist	(	const char *	p_name,
		t_size	p_name_length = `~0`
	)

Definition at line 517 of file playlist.cpp.

 {
     t_size index = find_playlist(p_name,p_name_length);
     if (index != pfc_infinite) return index;
     return create_playlist(p_name,p_name_length,pfc_infinite);
 }

t_size playlist_manager::find_or_create_playlist_unlocked	(	const char *	p_name,
		t_size	p_name_length = `~0`
	)

Definition at line 507 of file playlist.cpp.

                                                                                                    {
     t_size n, m = get_playlist_count();
     pfc::string_formatter temp;
     for(n=0;n<m;n++) {
         if (!playlist_lock_is_present(n) && playlist_get_name(n,temp)) {
             if (stricmp_utf8_ex(temp,~0,p_name,p_name_length) == 0) return n;
         }
     }
     return create_playlist(p_name,p_name_length,pfc_infinite);
 }

t_size playlist_manager::find_playlist	(	const char *	p_name,
		t_size	p_name_length = `~0`
	)

Definition at line 496 of file playlist.cpp.

 {
     t_size n, m = get_playlist_count();
     pfc::string_formatter temp;
     for(n=0;n<m;n++) {
         if (!playlist_get_name(n,temp)) break;
         if (stricmp_utf8_ex(temp,temp.length(),p_name,p_name_length) == 0) return n;
     }
     return pfc_infinite;
 }

void playlist_manager::g_make_selection_move_permutation	(	t_size *	p_output,
		t_size	p_count,
		const bit_array &	p_selection,
		int	p_delta
	)

static

Definition at line 123 of file playlist.cpp.

                                                                                                                                    {
     pfc::create_move_items_permutation(p_output,p_count,p_selection,p_delta);
 }

virtual t_size playlist_manager::get_active_playlist ( )

pure virtual

Retrieves index of active playlist; infinite if no playlist is active.

bool playlist_manager::get_all_items ( pfc::list_base_t< metadb_handle_ptr > & out )

Definition at line 619 of file playlist.cpp.

 {
     t_size n, m = get_playlist_count();
     if (m == pfc_infinite) return false;
     enum_items_callback_retrieve_all_items callback(out);
     for(n=0;n<m;n++)
     {
         playlist_enum_items(n,callback,bit_array_true());
     }
     return true;
 }

virtual bool playlist_manager::get_playing_item_location	(	t_size *	p_playlist,
		t_size *	p_index
	)

pure virtual

Retrieves playlist position of currently playing item.

Parameters

p_playlist	Receives index of playlist containing currently playing item on success.
p_index	Receives index of currently playing item in the playlist that contains it on success.

Returns: True on success, false on failure (not playing or currently played item has been removed from the playlist it was on when starting).

virtual t_size playlist_manager::get_playing_playlist ( )

pure virtual

Retrieves playlist from which items to be played are taken from.

virtual t_size playlist_manager::get_playlist_count ( )

pure virtual

Retrieves number of playlists.

bool playlist_manager::highlight_playing_item ( )

Helper; highlights currently playing item; returns true on success or false on failure (not playing or currently played item has been removed from playlist since playback started).

Definition at line 541 of file playlist.cpp.

 {
     t_size playlist,item;
     if (!get_playing_item_location(&playlist,&item)) return false;
     set_active_playlist(playlist);
     playlist_set_focus_item(playlist,item);
     playlist_set_selection(playlist,bit_array_true(),bit_array_one(item));
     playlist_ensure_visible(playlist,item);
     return true;
 }

virtual void playlist_manager::modify_callback	(	class playlist_callback *	p_callback,
		unsigned	p_flags
	)

pure virtual

Modifies flags indicating which calback methods are requested (playlist_callback version).

virtual void playlist_manager::modify_callback	(	class playlist_callback_single *	p_callback,
		unsigned	p_flags
	)

pure virtual

Modifies flags indicating which calback methods are requested (playlist_callback_single version).

virtual void playlist_manager::on_files_deleted_sorted ( const pfc::list_base_const_t< const char * > & p_items )

pure virtual

For internal use only; p_items must be sorted by metadb::path_compare; use file_operation_callback static methods instead of calling this directly.

virtual void playlist_manager::on_files_moved_sorted	(	const pfc::list_base_const_t< const char * > &	p_from,
		const pfc::list_base_const_t< const char * > &	p_to
	)

pure virtual

For internal use only; p_from must be sorted by metadb::path_compare; use file_operation_callback static methods instead of calling this directly.

virtual t_size playlist_manager::playback_order_get_active ( )

pure virtual

Retrieves index of active playback order mode.

virtual t_size playlist_manager::playback_order_get_count ( )

pure virtual

Retrieves number of available playback order modes.

virtual GUID playlist_manager::playback_order_get_guid ( t_size p_index )

pure virtual

Retrieves GUID of specified playback order mode. Used for managing playback modes without relying on names.

Parameters

p_index Index of playback order mode to query, from 0 to playback_order_get_count() return value - 1.

virtual const char* playlist_manager::playback_order_get_name ( t_size p_index )

pure virtual

Retrieves name of specified playback order move.

Parameters

p_index Index of playback order mode to query, from 0 to playback_order_get_count() return value - 1.

Returns: Null-terminated UTF-8 encoded string containing name of the playback order mode. Returned pointer points to statically allocated string and can be safely stored without having to free it later.

virtual void playlist_manager::playback_order_set_active ( t_size p_index )

pure virtual

Sets index of active playback order mode.

void playlist_manager::playlist_activate_delta ( int p_delta )

Definition at line 741 of file playlist.cpp.

                                                           {
     const t_size total = get_playlist_count();
     if (total > 0) {
         t_size active = get_active_playlist();
         
         //clip p_delta to -(total-1)...(total-1) range
         if (p_delta < 0) {
             p_delta = - ( (-p_delta) % (t_ssize)total );
         } else {
             p_delta = p_delta % total;
         }
         if (p_delta != 0) {
             if (active == pfc_infinite) {
                 //special case when no playlist is active
                 if (p_delta > 0) {
                     active = (t_size)(p_delta - 1);
                 } else {
                     active = (total + p_delta);//p_delta is negative
                 }
             } else {
                 active = (t_size) (active + total + p_delta) % total;
             }
             set_active_playlist(active % total);
         }
     }
 }

void playlist_manager::playlist_activate_next ( )

inline

Definition at line 358 of file playlist.h.

358 {playlist_activate_delta(1);}

playlist_manager::playlist_activate_delta

void playlist_activate_delta(int p_delta)

Definition: playlist.cpp:741

void playlist_manager::playlist_activate_previous ( )

inline

Definition at line 359 of file playlist.h.

359 {playlist_activate_delta(-1);}

playlist_manager::playlist_activate_delta

void playlist_activate_delta(int p_delta)

Definition: playlist.cpp:741

bool playlist_manager::playlist_add_items	(	t_size	playlist,
		const pfc::list_base_const_t< metadb_handle_ptr > &	data,
		const bit_array &	p_selection
	)

Definition at line 338 of file playlist.cpp.

 {
     return playlist_insert_items(playlist,pfc_infinite,data,p_selection) != pfc_infinite;
 }

bool playlist_manager::playlist_add_items_filter	(	t_size	p_playlist,
		const pfc::list_base_const_t< metadb_handle_ptr > &	p_data,
		bool	p_select
	)

Definition at line 381 of file playlist.cpp.

 {
     return playlist_insert_items_filter(p_playlist,pfc_infinite,p_data,p_select);
 }

bool playlist_manager::playlist_add_locations	(	t_size	p_playlist,
		const pfc::list_base_const_t< const char * > &	p_urls,
		bool	p_select,
		HWND	p_parentwnd
	)

Definition at line 391 of file playlist.cpp.

 {
     return playlist_insert_locations(p_playlist,pfc_infinite,p_urls,p_select,p_parentwnd);
 }

void playlist_manager::playlist_clear ( t_size p_playlist )

Clears contents of specified playlist (removes all items from it).

Definition at line 276 of file playlist.cpp.

 {
     playlist_remove_items(p_playlist,bit_array_true());
 }

void playlist_manager::playlist_clear_selection ( t_size p_playlist )

Definition at line 405 of file playlist.cpp.

 {
     playlist_set_selection(p_playlist,bit_array_true(),bit_array_false());
 }

virtual void playlist_manager::playlist_ensure_visible	(	t_size	p_playlist,
		t_size	p_item
	)

pure virtual

Tells playlist renderers to make sure that specified item is visible.

virtual void playlist_manager::playlist_enum_items	(	t_size	p_playlist,
		enum_items_callback &	p_callback,
		const bit_array &	p_mask
	)

pure virtual

Enumerates contents of specified playlist.

virtual bool playlist_manager::playlist_execute_default_action	(	t_size	p_playlist,
		t_size	p_item
	)

pure virtual

Executes default doubleclick/enter action for specified item on specified playlist (starts playing the item unless overridden by a lock to do something else).

bool playlist_manager::playlist_find_item	(	t_size	p_playlist,
		metadb_handle_ptr	p_item,
		t_size &	p_result
	)

Definition at line 821 of file playlist.cpp.

                                                                                                       {
     enum_items_callback_find_item callback(p_item);
     playlist_enum_items(p_playlist,callback,bit_array_true());
     t_size result = callback.result();
     if (result == pfc_infinite) return false;
     p_result = result;
     return true;
 }

bool playlist_manager::playlist_find_item_selected	(	t_size	p_playlist,
		metadb_handle_ptr	p_item,
		t_size &	p_result
	)

Definition at line 829 of file playlist.cpp.

                                                                                                                {
     enum_items_callback_find_item_selected callback(p_item);
     playlist_enum_items(p_playlist,callback,bit_array_true());
     t_size result = callback.result();
     if (result == pfc_infinite) return false;
     p_result = result;
     return true;
 }

void playlist_manager::playlist_get_all_items	(	t_size	p_playlist,
		pfc::list_base_t< metadb_handle_ptr > &	out
	)

Definition at line 86 of file playlist.cpp.

 {
     playlist_get_items(p_playlist,out,bit_array_true());
 }

virtual t_size playlist_manager::playlist_get_focus_item ( t_size p_playlist )

pure virtual

Retrieves index of focus item on specified playlist; returns infinite when no item has focus.

bool playlist_manager::playlist_get_focus_item_handle	(	metadb_handle_ptr &	p_item,
		t_size	p_playlist
	)

Definition at line 482 of file playlist.cpp.

 {
     t_size index = playlist_get_focus_item(p_playlist);
     if (index == pfc_infinite) return false;
     return playlist_get_item_handle(p_out,p_playlist,index);
 }

virtual t_size playlist_manager::playlist_get_item_count ( t_size p_playlist )

pure virtual

Retrieves number of items on specified playlist.

bool playlist_manager::playlist_get_item_handle	(	metadb_handle_ptr &	p_out,
		t_size	p_playlist,
		t_size	p_item
	)

Helper; retrieves metadb_handle of the specified playlist item. Returns true on success, false on failure (invalid parameters).

Definition at line 115 of file playlist.cpp.

 {
     enum_items_callback_retrieve_item callback;
     playlist_enum_items(p_playlist,callback,bit_array_one(p_item));
     p_out = callback.get_item();
     return p_out.is_valid();
 }

metadb_handle_ptr playlist_manager::playlist_get_item_handle	(	t_size	playlist,
		t_size	item
	)

Helper; retrieves metadb_handle of the specified playlist item; throws pfc::exception_invalid_params() on failure.

Definition at line 108 of file playlist.cpp.

                                                                                          {
     metadb_handle_ptr temp;
     if (!playlist_get_item_handle(temp, playlist, item)) throw pfc::exception_invalid_params();
     PFC_ASSERT( temp.is_valid() );
     return temp;
 
 }

void playlist_manager::playlist_get_items	(	t_size	p_playlist,
		pfc::list_base_t< metadb_handle_ptr > &	out,
		const bit_array &	p_mask
	)

Definition at line 552 of file playlist.cpp.

 {
     playlist_enum_items(p_playlist,enum_items_callback_retrieve_all_items(out),p_mask);
 }

virtual bool playlist_manager::playlist_get_name	(	t_size	p_playlist,
		pfc::string_base &	p_out
	)

pure virtual

Retrieves name of specified playlist. Should never fail unless the parameters are invalid.

t_size playlist_manager::playlist_get_selected_count	(	t_size	p_playlist,
		bit_array const &	p_mask
	)

Definition at line 780 of file playlist.cpp.

                                                                                                {
     enum_items_callback_get_selected_count callback;
     playlist_enum_items(p_playlist,callback,p_mask);
     return callback.get_count();
 }

void playlist_manager::playlist_get_selected_items	(	t_size	p_playlist,
		pfc::list_base_t< metadb_handle_ptr > &	out
	)

Definition at line 91 of file playlist.cpp.

 {
     playlist_enum_items(p_playlist,enum_items_callback_retrieve_selected_items(out),bit_array_true());
 }

t_size playlist_manager::playlist_get_selection_count	(	t_size	p_playlist,
		t_size	p_max
	)

Definition at line 468 of file playlist.cpp.

 {
     enum_items_callback_count_selection callback(p_max);
     playlist_enum_items(p_playlist,callback,bit_array_true());
     return callback.get_count();
 }

void playlist_manager::playlist_get_selection_mask	(	t_size	p_playlist,
		bit_array_var &	out
	)

Retrieves selection map of specific playlist, using bit_array_var interface.

Definition at line 96 of file playlist.cpp.

 {
     playlist_enum_items(p_playlist,enum_items_callback_retrieve_selection_mask(out),bit_array_true());
 }

virtual t_size playlist_manager::playlist_insert_items	(	t_size	p_playlist,
		t_size	p_base,
		const pfc::list_base_const_t< metadb_handle_ptr > &	data,
		const bit_array &	p_selection
	)

pure virtual

Inserts new items into specified playlist, at specified position.

bool playlist_manager::playlist_insert_items_filter	(	t_size	p_playlist,
		t_size	p_base,
		const pfc::list_base_const_t< metadb_handle_ptr > &	p_data,
		bool	p_select
	)

Definition at line 350 of file playlist.cpp.

 {
     metadb_handle_list temp;
     static_api_ptr_t<playlist_incoming_item_filter> api;
     if (!api->filter_items(p_data,temp))
         return false;
     return playlist_insert_items(p_playlist,p_base,temp,bit_array_val(p_select)) != pfc_infinite;
 }

bool playlist_manager::playlist_insert_locations	(	t_size	p_playlist,
		t_size	p_base,
		const pfc::list_base_const_t< const char * > &	p_urls,
		bool	p_select,
		HWND	p_parentwnd
	)

Deprecated:: (since 0.9.3) Use playlist_incoming_item_filter_v2::process_locations_async whenever possible

Definition at line 366 of file playlist.cpp.

 {
     metadb_handle_list temp;
     static_api_ptr_t<playlist_incoming_item_filter> api;
     if (!api->process_locations(p_urls,temp,true,0,0,p_parentwnd)) return false;
     return playlist_insert_items(p_playlist,p_base,temp,bit_array_val(p_select)) != pfc_infinite;
 }

bool playlist_manager::playlist_is_item_selected	(	t_size	p_playlist,
		t_size	p_item
	)

Helper; returns whether specified item on specified playlist is selected or not.

Definition at line 101 of file playlist.cpp.

 {
     enum_items_callback_retrieve_selection callback;
     playlist_enum_items(p_playlist,callback,bit_array_one(p_item));
     return callback.get_state();
 }

virtual bool playlist_manager::playlist_is_redo_available ( t_size p_playlist )

pure virtual

Returns whether a redo restore point is available for specified playlist.

virtual bool playlist_manager::playlist_is_undo_available ( t_size p_playlist )

pure virtual

Returns whether an undo restore point is available for specified playlist.

virtual void playlist_manager::playlist_item_format_title	(	t_size	p_playlist,
		t_size	p_item,
		titleformat_hook *	p_hook,
		pfc::string_base &	p_out,
		const service_ptr_t< titleformat_object > &	p_script,
		titleformat_text_filter *	p_filter,
		playback_control::t_display_level	p_playback_info_level
	)

pure virtual

Renders information about specified playlist item, using specified titleformatting script parameters.

Parameters

p_playlist	Index of playlist containing item being processed.
p_item	Index of item being processed in the playlist containing it.
p_hook	Titleformatting script hook to use; see titleformat_hook documentation for more info. Set to NULL when hook functionality is not needed.
p_out	String object receiving results.
p_script	Compiled titleformatting script to use; see titleformat_object cocumentation for more info.
p_filter	Text filter to use; see titleformat_text_filter documentation for more info. Set to NULL when text filter functionality is not needed.
p_playback_info_level	Level of playback related information requested. See playback_control::t_display_level documentation for more info.

virtual t_uint32 playlist_manager::playlist_lock_get_filter_mask ( t_size p_playlist )

pure virtual

virtual bool playlist_manager::playlist_lock_install	(	t_size	p_playlist,
		const service_ptr_t< playlist_lock > &	p_lock
	)

pure virtual

virtual bool playlist_manager::playlist_lock_is_present ( t_size p_playlist )

pure virtual

virtual bool playlist_manager::playlist_lock_query_name	(	t_size	p_playlist,
		pfc::string_base &	p_out
	)

pure virtual

virtual bool playlist_manager::playlist_lock_show_ui ( t_size p_playlist )

pure virtual

virtual bool playlist_manager::playlist_lock_uninstall	(	t_size	p_playlist,
		const service_ptr_t< playlist_lock > &	p_lock
	)

pure virtual

bool playlist_manager::playlist_move_selection	(	t_size	p_playlist,
		int	p_delta
	)

Moves selected items up/down in the playlist by specified offset.

Parameters

p_playlist	Index of playlist to alter.
p_delta	Offset to move items by. Set it to a negative valuye to move up, or to a positive value to move down.

Returns: True on success, false on failure (e.g. playlist locked).

Definition at line 127 of file playlist.cpp.

                                                                             {
     if (p_delta==0) return true;
     
     t_size count = playlist_get_item_count(p_playlist);
     
     pfc::array_t<t_size> order; order.set_size(count);
     pfc::array_t<bool> selection; selection.set_size(count);
     
     playlist_get_selection_mask(p_playlist,bit_array_var_table(selection.get_ptr(),selection.get_size()));
     g_make_selection_move_permutation(order.get_ptr(),count,bit_array_table(selection.get_ptr(),selection.get_size()),p_delta);
     return playlist_reorder_items(p_playlist,order.get_ptr(),count);
 }

virtual bool playlist_manager::playlist_redo_restore ( t_size p_playlist )

pure virtual

Reverts specified playlist to next redo restore point and generates an undo restore point.

Returns: True on success, false on failure (playlist locked or no restore point available).

virtual bool playlist_manager::playlist_remove_items	(	t_size	p_playlist,
		const bit_array &	mask
	)

pure virtual

Removes specified items from specified playlist. Returns true on success or false on failure (playlist locked).

void playlist_manager::playlist_remove_selection	(	t_size	p_playlist,
		bool	p_crop = `false`
	)

Definition at line 436 of file playlist.cpp.

 {
     bit_array_bittable table(playlist_get_item_count(p_playlist));
     playlist_get_selection_mask(p_playlist,table);
     if (p_crop) playlist_remove_items(p_playlist,bit_array_not(table));
     else playlist_remove_items(p_playlist,table);
 }

virtual bool playlist_manager::playlist_rename	(	t_size	p_index,
		const char *	p_name,
		t_size	p_name_length
	)

pure virtual

Renames specified playlist.

Parameters

p_name	New name of playlist; a UTF-8 encoded string.
p_name_length	Length limit of playlist name string, in bytes (actual string may be shorter if null terminator is encountered before). Set this to infinite to use plain null-terminated strings.

Returns: True on success, false on failure (playlist locked).

virtual bool playlist_manager::playlist_reorder_items	(	t_size	p_playlist,
		const t_size *	p_order,
		t_size	p_count
	)

pure virtual

Reorders items in specified playlist according to specified permutation.

virtual bool playlist_manager::playlist_replace_item	(	t_size	p_playlist,
		t_size	p_item,
		const metadb_handle_ptr &	p_new_item
	)

pure virtual

Replaces specified item on specified playlist. Returns true on success or false on failure (playlist locked).

t_size playlist_manager::playlist_set_focus_by_handle	(	t_size	p_playlist,
		metadb_handle_ptr	p_item
	)

Definition at line 837 of file playlist.cpp.

                                                                                                 {
     t_size index;
     if (!playlist_find_item(p_playlist,p_item,index)) index = pfc_infinite;
     playlist_set_focus_item(p_playlist,index);
     return index;
 }

virtual void playlist_manager::playlist_set_focus_item	(	t_size	p_playlist,
		t_size	p_item
	)

pure virtual

Sets index of focus item on specified playlist; use infinite to set no focus item.

virtual void playlist_manager::playlist_set_selection	(	t_size	p_playlist,
		const bit_array &	p_affected,
		const bit_array &	p_status
	)

pure virtual

Selects/deselects items on specified playlist.

Parameters

p_playlist	Index of playlist to alter.
p_affected	Mask of items to alter.
p_status	Mask of selected/deselected state to apply to items specified by p_affected.

void playlist_manager::playlist_set_selection_single	(	t_size	p_playlist,
		t_size	p_item,
		bool	p_state
	)

Definition at line 457 of file playlist.cpp.

 {
     playlist_set_selection(p_playlist,bit_array_one(p_item),bit_array_val(p_state));
 }

virtual bool playlist_manager::playlist_sort_by_format	(	t_size	p_playlist,
		const char *	p_pattern,
		bool	p_sel_only
	)

pure virtual

Sorts specified playlist - entire playlist or selection only - by specified title formatting pattern, or randomizes the order.

Parameters

p_playlist	Index of playlist to alter.
p_pattern	Title formatting pattern to sort by (an UTF-8 encoded null-termindated string). Set to NULL to randomize the order of items.
p_sel_only	Set to false to sort/randomize whole playlist, or to true to sort/randomize only selection on the playlist.

Returns: True on success, false on failure (playlist locked etc).

virtual void playlist_manager::playlist_undo_backup ( t_size p_playlist )

pure virtual

Creates an undo restore point for specified playlist.

virtual bool playlist_manager::playlist_undo_restore ( t_size p_playlist )

pure virtual

Reverts specified playlist to last undo restore point and generates a redo restore point.

Returns: True on success, false on failure (playlist locked or no restore point available).

bool playlist_manager::playlist_update_content	(	t_size	playlist,
		metadb_handle_list_cref	content,
		bool	bUndoBackup
	)

Changes contents of the specified playlist to the specified items, trying to reuse existing playlist content as much as possible (preserving selection/focus/etc). Order of items in playlist not guaranteed to be the same as in the specified item list.

Returns: true if the playlist has been altered, false if there was nothing to update.

Definition at line 287 of file playlist.cpp.

                                                                                                                  {
     metadb_handle_list old;
     playlist_get_all_items(playlist, old);
     if (old.get_size() == 0) {
         if (content.get_size() == 0) return false;
         if (bUndoBackup) playlist_undo_backup(playlist);
         playlist_add_items(playlist, content, bit_array_false());
         return true;
     }
     pfc::avltree_t<metadb_handle::nnptr> itemsOld, itemsNew;
 
     for(t_size walk = 0; walk < old.get_size(); ++walk) itemsOld += old[walk];
     for(t_size walk = 0; walk < content.get_size(); ++walk) itemsNew += content[walk];
     bit_array_bittable removeMask(old.get_size());
     bit_array_bittable filterMask(content.get_size());
     bool gotNew = false, filterNew = false, gotRemove = false;
     for(t_size walk = 0; walk < content.get_size(); ++walk) {
         const bool state = !itemsOld.have_item(content[walk]);
         if (state) gotNew = true;
         else filterNew = true;
         filterMask.set(walk, state);
     }
     for(t_size walk = 0; walk < old.get_size(); ++walk) {
         const bool state = !itemsNew.have_item(old[walk]);
         if (state) gotRemove = true;
         removeMask.set(walk, state);
     }
     if (!gotNew && !gotRemove) return false;
     if (bUndoBackup) playlist_undo_backup(playlist);
     if (gotRemove) {
         playlist_remove_items(playlist, removeMask);
     }
     if (gotNew) {
         if (filterNew) {
             metadb_handle_list temp(content);
             temp.filter_mask(filterMask);
             playlist_add_items(playlist, temp, bit_array_false());
         } else {
             playlist_add_items(playlist, content, bit_array_false());
         }
     }
 
     {
         playlist_get_all_items(playlist, old);
         pfc::array_t<t_size> order;
         if (pfc::guess_reorder_pattern<pfc::list_base_const_t<metadb_handle_ptr> >(order, old, content)) {
             playlist_reorder_items(playlist, order.get_ptr(), order.get_size());
         }
     }
     return true;
 }

virtual void playlist_manager::queue_add_item ( metadb_handle_ptr p_item )

pure virtual

virtual void playlist_manager::queue_add_item_playlist	(	t_size	p_playlist,
		t_size	p_item
	)

pure virtual

virtual t_size playlist_manager::queue_find_index ( t_playback_queue_item const & p_item )

pure virtual

Returns index (0-based) on success, infinite on failure (item not in queue).

void playlist_manager::queue_flush ( )

inline

Helper; removes all items from the playback queue.

Definition at line 235 of file playlist.h.

235 {queue_remove_mask(bit_array_true());}

bit_array_true

Definition: bit_array_impl.h:111

playlist_manager::queue_remove_mask

virtual void queue_remove_mask(bit_array const &p_mask)=0

virtual void playlist_manager::queue_get_contents ( pfc::list_base_t< t_playback_queue_item > & p_out )

pure virtual

virtual t_size playlist_manager::queue_get_count ( )

pure virtual

bool playlist_manager::queue_is_active ( )

inline

Helper; returns whether there are items in the playback queue.

Definition at line 237 of file playlist.h.

237 {return queue_get_count() > 0;}

playlist_manager::queue_get_count

virtual t_size queue_get_count()=0

virtual void playlist_manager::queue_remove_mask ( bit_array const & p_mask )

pure virtual

virtual void playlist_manager::register_callback	(	class playlist_callback *	p_callback,
		unsigned	p_flags
	)

pure virtual

Registers a playlist callback; registered object receives notifications about any modifications of any of loaded playlists.

Parameters

p_callback	Callback interface to register.
p_flags	Flags indicating which callback methods are requested. See playlist_callback::flag_* constants for more info. The main purpose of flags parameter is working set optimization by not calling methods that do nothing.

virtual void playlist_manager::register_callback	(	class playlist_callback_single *	p_callback,
		unsigned	p_flags
	)

pure virtual

Registers a playlist callback; registered object receives notifications about any modifications of active playlist.

Parameters

p_callback	Callback interface to register.
p_flags	Flags indicating which callback methods are requested. See playlist_callback_single::flag_* constants for more info. The main purpose of flags parameter is working set optimization by not calling methods that do nothing.

void playlist_manager::remove_items_from_all_playlists ( const pfc::list_base_const_t< metadb_handle_ptr > & p_data )

Definition at line 598 of file playlist.cpp.

 {
     t_size playlist_num, playlist_max = get_playlist_count();
     if (playlist_max != pfc_infinite)
     {
         metadb_handle_list temp;
         temp.add_items(p_data);
         temp.sort_by_pointer();
         for(playlist_num = 0; playlist_num < playlist_max; playlist_num++ )
         {
             t_size playlist_item_count = playlist_get_item_count(playlist_num);
             if (playlist_item_count == pfc_infinite) break;
             bit_array_bittable table(playlist_item_count);
             enum_items_callback_remove_list callback(temp,table);
             playlist_enum_items(playlist_num,callback,bit_array_true());
             if (callback.get_found()>0)
                 playlist_remove_items(playlist_num,table);
         }
     }
 }

bool playlist_manager::remove_playlist ( t_size p_playlist )

Helper; removes single playlist of specified index.

Definition at line 266 of file playlist.cpp.

 {
     return remove_playlists(bit_array_one(idx));
 }

bool playlist_manager::remove_playlist_switch ( t_size p_playlist )

Helper; removes single playlist of specified index, and switches to another playlist when possible.

Definition at line 652 of file playlist.cpp.

 {
     bool need_switch = get_active_playlist() == idx;
     if (remove_playlist(idx))
     {
         if (need_switch)
         {
             t_size total = get_playlist_count();
             if (total > 0)
             {
                 if (idx >= total) idx = total-1;
                 set_active_playlist(idx);
             }
         }
         return true;
     }
     else return false;
 }

virtual bool playlist_manager::remove_playlists ( const bit_array & p_mask )

pure virtual

Removes playlists according to specified mask. See also: bit_array.

virtual bool playlist_manager::reorder	(	const t_size *	p_order,
		t_size	p_count
	)

pure virtual

Reorders the playlist list according to specified permutation.

Returns: True on success, false on failure (call from invalid context).

void playlist_manager::reset_playing_playlist ( )

Definition at line 400 of file playlist.cpp.

 {
     set_playing_playlist(get_active_playlist());
 }

virtual void playlist_manager::set_active_playlist ( t_size p_index )

pure virtual

Sets active playlist (infinite to set no active playlist).

virtual void playlist_manager::set_playing_playlist ( t_size p_index )

pure virtual

Sets playlist from which items to be played are taken from.

virtual void playlist_manager::unregister_callback ( class playlist_callback * p_callback )

pure virtual

Unregisters a playlist callback (playlist_callback version).

virtual void playlist_manager::unregister_callback ( class playlist_callback_single * p_callback )

pure virtual

Unregisters a playlist callback (playlist_callback_single version).

The documentation for this class was generated from the following files:

foobar2000/SDK/playlist.h
foobar2000/SDK/playlist.cpp

Data Structures

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Member Function Documentation