playlist_manager

#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.

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

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.

{playlist_activate_delta(1);}

void playlist_manager::playlist_activate_previous ( )

inline

Definition at line 359 of file playlist.h.

{playlist_activate_delta(-1);}

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.

{queue_remove_mask(bit_array_true());}

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.

{return 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