[Mplayerxp-cvslog] SF.net SVN: mplayerxp:[608] mplayerxp
Brought to you by:
olov
Menu
▾
▴
[Mplayerxp-cvslog] SF.net SVN: mplayerxp:[608] mplayerxp
|
From: <nic...@us...> - 2012-12-27 16:37:35
|
Revision: 608
http://mplayerxp.svn.sourceforge.net/mplayerxp/?rev=608&view=rev
Author: nickols_k
Date: 2012-12-27 16:37:25 +0000 (Thu, 27 Dec 2012)
Log Message:
-----------
convert struct play_tree_t into class PlayTree
Modified Paths:
--------------
TODO
mplayerxp/libmpconf/cfgparser.cpp
mplayerxp/libmpconf/cfgparser.h
mplayerxp/libplaytree/asxparser.cpp
mplayerxp/libplaytree/asxparser.h
mplayerxp/libplaytree/playtree.cpp
mplayerxp/libplaytree/playtree.h
mplayerxp/libplaytree/playtreeparser.cpp
mplayerxp/libplaytree/playtreeparser.h
mplayerxp/mplayerxp.cpp
mplayerxp/postproc/libmenu/menu_pt.cpp
Modified: TODO
===================================================================
--- TODO 2012-12-27 14:05:33 UTC (rev 607)
+++ TODO 2012-12-27 16:37:25 UTC (rev 608)
@@ -1,5 +1,6 @@
TODO for mplayerxp:
+- remove m_config_t from libplaytree: implement config independed container
- Implement libmpdemux3:
class Demuxer_Driver {
Demuxer_Driver(Demuxer& parent);
Modified: mplayerxp/libmpconf/cfgparser.cpp
===================================================================
--- mplayerxp/libmpconf/cfgparser.cpp 2012-12-27 14:05:33 UTC (rev 607)
+++ mplayerxp/libmpconf/cfgparser.cpp 2012-12-27 16:37:25 UTC (rev 608)
@@ -193,7 +193,7 @@
return ret;
}
-m_config_t& m_config_new(play_tree_t* pt,libinput_t&libinput) {
+m_config_t& m_config_new(PlayTree* pt,libinput_t&libinput) {
m_config_t& config = *new(zeromem) m_config_t(libinput);
config.config_stack = (config_save_t**)mp_calloc(1,sizeof(config_save_t*));
SET_GLOBAL(config); // We always start with global options
@@ -228,13 +228,13 @@
}
static int config_is_entry_option(m_config_t& config,const std::string& opt,const std::string& param) {
- play_tree_t* entry = NULL;
+ PlayTree* entry = NULL;
std::string lopt=opt;
std::transform(lopt.begin(),lopt.end(),lopt.begin(), ::tolower);
if(lopt=="playlist") { // We handle playlist here
if(param.empty()) return ERR_MISSING_PARAM;
- entry = parse_playlist_file(config.libinput,param);
+ entry = PlayTree::parse_playlist_file(config.libinput,param);
if(!entry) {
mpxp_err<<"Playlist parsing failed: "<<param<<std::endl;
return 1;
@@ -242,8 +242,8 @@
}
if(entry) {
- if(config.last_entry) play_tree_append_entry(config.last_entry,entry);
- else play_tree_set_child(config.pt,entry);
+ if(config.last_entry) config.last_entry->append_entry(entry);
+ else config.pt->set_child(entry);
config.last_entry = entry;
if(config.parser_mode == COMMAND_LINE) UNSET_GLOBAL(config);
return 1;
@@ -449,15 +449,15 @@
}
out:
if(ret >= 0 && ! IS_RUNNING(config) && ! IS_GLOBAL(config) && ! (conf[i].flags & CONF_GLOBAL) && conf[i].type != CONF_TYPE_SUBCONFIG ) {
- play_tree_t* dest = config.last_entry ? config.last_entry : config.last_parent;
+ PlayTree* dest = config.last_entry ? config.last_entry : config.last_parent;
std::string o;
if(config.sub_conf) o=std::string(config.sub_conf)+":"+opt;
else o=opt;
if(ret == 0)
- play_tree_set_param(dest,o,"");
+ dest->set_param(o,"");
else if(ret > 0)
- play_tree_set_param(dest,o,param);
+ dest->set_param(o,param);
m_config_pop(config);
}
return ret;
@@ -728,12 +728,12 @@
continue;
}
if(opt[0] == '{' && opt[1] == '\0') {
- play_tree_t* entry = play_tree_new();
+ PlayTree* entry = new(zeromem) PlayTree;
UNSET_GLOBAL(config);
if(config.last_entry == NULL) {
- play_tree_set_child(config.last_parent,entry);
+ config.last_parent->set_child(entry);
} else {
- play_tree_append_entry(config.last_entry,entry);
+ config.last_entry->append_entry(entry);
config.last_entry = NULL;
}
config.last_parent = entry;
@@ -741,12 +741,12 @@
}
if(opt[0] == '}' && opt[1] == '\0') {
- if( ! config.last_parent || ! config.last_parent->parent) {
+ if( ! config.last_parent || ! config.last_parent->get_parent()) {
mpxp_err<<"too much }-"<<std::endl;
goto err_out;
}
config.last_entry = config.last_parent;
- config.last_parent = config.last_entry->parent;
+ config.last_parent = config.last_entry->get_parent();
continue;
}
@@ -788,14 +788,14 @@
break;
}
} else /* filename */ {
- play_tree_t* entry = play_tree_new();
+ PlayTree* entry = new(zeromem) PlayTree;
mpxp_dbg2<<"Adding file "<<argv[i]<<std::endl;
- play_tree_add_file(entry,argv[i]);
+ entry->add_file(argv[i]);
if(argv[i]=="-") m_config_set_option(config,"use-stdin",NULL);
/* opt is not an option -> treat it as a filename */
UNSET_GLOBAL(config); // We start entry specific options
- if(config.last_entry == NULL) play_tree_set_child(config.last_parent,entry);
- else play_tree_append_entry(config.last_entry,entry);
+ if(config.last_entry == NULL) config.last_parent->set_child(entry);
+ else config.last_entry->append_entry(entry);
config.last_entry = entry;
}
}
Modified: mplayerxp/libmpconf/cfgparser.h
===================================================================
--- mplayerxp/libmpconf/cfgparser.h 2012-12-27 14:05:33 UTC (rev 607)
+++ mplayerxp/libmpconf/cfgparser.h 2012-12-27 16:37:25 UTC (rev 608)
@@ -10,8 +10,8 @@
namespace mpxp {
struct libinput_t;
+ struct PlayTree;
}
-struct play_tree_t;
/* config types */
enum {
CONF_TYPE_FLAG =0,
@@ -64,9 +64,9 @@
int parser_mode; /* COMMAND_LINE or CONFIG_FILE */
int flags;
const char* sub_conf; // When we save a subconfig
- play_tree_t* pt; // play tree we use for playlist option, etc
- play_tree_t* last_entry; // last added entry
- play_tree_t* last_parent; // if last_entry is NULL we must create child of this
+ PlayTree* pt; // play tree we use for playlist option, etc
+ PlayTree* last_entry; // last added entry
+ PlayTree* last_parent; // if last_entry is NULL we must create child of this
int recursion_depth;
libinput_t& libinput;
};
@@ -96,7 +96,7 @@
MPXP_Rc mpxp_parse_command_line(m_config_t& config, const std::vector<std::string>& argv,const std::map<std::string,std::string>& envm);
}
-m_config_t& m_config_new(play_tree_t* pt,libinput_t&libinput);
+m_config_t& m_config_new(PlayTree* pt,libinput_t&libinput);
void m_config_free(m_config_t* config);
Modified: mplayerxp/libplaytree/asxparser.cpp
===================================================================
--- mplayerxp/libplaytree/asxparser.cpp 2012-12-27 14:05:33 UTC (rev 607)
+++ mplayerxp/libplaytree/asxparser.cpp 2012-12-27 16:37:25 UTC (rev 608)
@@ -295,7 +295,7 @@
return 1;
}
-void ASX_Parser::param(ASX_Attrib& cattribs, play_tree_t* pt) const {
+void ASX_Parser::param(ASX_Attrib& cattribs, PlayTree* pt) const {
std::string name,val;
name = cattribs.get("NAME");
@@ -310,10 +310,10 @@
else mpxp_warn<<std::endl;
return;
}
- play_tree_set_param(pt,name,val);
+ pt->set_param(name,val);
}
-void ASX_Parser::ref(ASX_Attrib& cattribs, play_tree_t* pt) const {
+void ASX_Parser::ref(ASX_Attrib& cattribs, PlayTree* pt) const {
std::string href;
href = cattribs.get("HREF");
@@ -325,12 +325,12 @@
if (href.substr(0,7)=="http://") {
href = "mms"+href;
}
- play_tree_add_file(pt,href);
+ pt->add_file(href);
mpxp_v<<"Adding file "<<href<<" to element entry"<<std::endl;
}
-play_tree_t* ASX_Parser::entryref(libinput_t& libinput,const char* buffer,ASX_Attrib& _attribs) const {
- play_tree_t* pt;
+PlayTree* ASX_Parser::entryref(libinput_t& libinput,const char* buffer,ASX_Attrib& _attribs) const {
+ PlayTree* pt;
std::string href;
Stream* stream;
play_tree_parser_t* ptp;
@@ -363,13 +363,13 @@
return pt;
}
-play_tree_t* ASX_Parser::entry(const char* buffer,ASX_Attrib& _attribs) {
+PlayTree* ASX_Parser::entry(const char* buffer,ASX_Attrib& _attribs) {
ASX_Element element;
int r,nref=0;
- play_tree_t *pt_ref;
+ PlayTree *pt_ref;
UNUSED(_attribs);
- pt_ref = play_tree_new();
+ pt_ref = new(zeromem) PlayTree;
while(buffer && buffer[0] != '\0') {
r = get_element(&buffer,element);
@@ -386,28 +386,29 @@
} else mpxp_dbg2<<"Ignoring element "<<element.name()<<std::endl;
}
if(nref <= 0) {
- play_tree_free(pt_ref,1);
+ pt_ref->free(1);
+ delete pt_ref;
return NULL;
}
return pt_ref;
}
-play_tree_t* ASX_Parser::repeat(libinput_t&libinput,const char* buffer,ASX_Attrib& _attribs) {
+PlayTree* ASX_Parser::repeat(libinput_t&libinput,const char* buffer,ASX_Attrib& _attribs) {
ASX_Element element;
- play_tree_t *pt_repeat, *list=NULL, *pt_entry;
+ PlayTree *pt_repeat, *list=NULL, *pt_entry;
std::string count;
int r;
- pt_repeat = play_tree_new();
+ pt_repeat = new(zeromem) PlayTree;
count = _attribs.get("COUNT");
if(count.empty()) {
mpxp_dbg2<<"Setting element repeat loop to infinit"<<std::endl;
- pt_repeat->loop = -1; // Infinit
+ pt_repeat->set_loop(-1); // Infinit
} else {
- pt_repeat->loop = ::atoi(count.c_str());
- if(pt_repeat->loop == 0) pt_repeat->loop = 1;
- mpxp_dbg2<<"Setting element repeat loop to "<<pt_repeat->loop<<std::endl;
+ pt_repeat->set_loop(::atoi(count.c_str()));
+ if(pt_repeat->get_loop() == 0) pt_repeat->set_loop(1);
+ mpxp_dbg2<<"Setting element repeat loop to "<<pt_repeat->get_loop()<<std::endl;
}
while(buffer && buffer[0] != '\0') {
@@ -422,21 +423,21 @@
pt_entry = entry(element.body().c_str(),element.attribs());
if(pt_entry) {
if(!list) list = pt_entry;
- else play_tree_append_entry(list,pt_entry);
+ else list->append_entry(pt_entry);
mpxp_dbg2<<"Adding element "<<element.name()<<" to repeat"<<std::endl;
}
} else if(uname=="ENTRYREF") {
pt_entry = entryref(libinput,element.body().c_str(),element.attribs());
if(pt_entry) {
if(!list) list = pt_entry;
- else play_tree_append_entry(list,pt_entry);
+ else list->append_entry(pt_entry);
mpxp_dbg2<<"Adding element "<<element.name()<<" to repeat"<<std::endl;
}
} else if(uname=="REPEAT") {
pt_entry = repeat(libinput,element.body().c_str(),element.attribs());
if(pt_entry) {
if(!list) list = pt_entry;
- else play_tree_append_entry(list,pt_entry);
+ else list->append_entry(pt_entry);
mpxp_dbg2<<"Adding element "<<element.name()<<" to repeat"<<std::endl;
}
} else if(uname=="PARAM") {
@@ -445,17 +446,18 @@
}
if(!list) {
- play_tree_free(pt_repeat,1);
+ pt_repeat->free(1);
+ delete pt_repeat;
return NULL;
}
- play_tree_set_child(pt_repeat,list);
+ pt_repeat->set_child(list);
return pt_repeat;
}
-play_tree_t* ASX_Parser::build_tree(libinput_t&libinput,const char* buffer,int deep) {
+PlayTree* ASX_Parser::build_tree(libinput_t&libinput,const char* buffer,int deep) {
ASX_Element asx_element,element;
int r;
- play_tree_t *asx,*pt_entry,*list = NULL;
+ PlayTree *asx,*pt_entry,*list = NULL;
ASX_Parser& parser = *new(zeromem) ASX_Parser;
parser.line = 1;
@@ -486,7 +488,7 @@
return NULL;
}
- asx = play_tree_new();
+ asx = new(zeromem) PlayTree;
buffer = asx_element.body().c_str();
while(buffer && buffer[0] != '\0') {
r = parser.get_element(&buffer,element);
@@ -501,21 +503,21 @@
pt_entry = parser.entry(element.body().c_str(),element.attribs());
if(pt_entry) {
if(!list) list = pt_entry;
- else play_tree_append_entry(list,pt_entry);
+ else list->append_entry(pt_entry);
mpxp_dbg2<<"Adding element "<<element.name()<<" to asx"<<std::endl;
}
} else if(uname=="ENTRYREF") {
pt_entry = parser.entryref(libinput,element.body().c_str(),element.attribs());
if(pt_entry) {
if(!list) list = pt_entry;
- else play_tree_append_entry(list,pt_entry);
+ else list->append_entry(pt_entry);
mpxp_dbg2<<"Adding element "<<element.name()<<" to asx"<<std::endl;
}
} else if(uname=="REPEAT") {
pt_entry = parser.repeat(libinput,element.body().c_str(),element.attribs());
if(pt_entry) {
if(!list) list = pt_entry;
- else play_tree_append_entry(list,pt_entry);
+ else list->append_entry(pt_entry);
mpxp_dbg2<<"Adding element "<<element.name()<<" to asx"<<std::endl;
}
} else mpxp_dbg2<<"Ignoring element "<<element.name()<<std::endl;
@@ -524,10 +526,11 @@
delete &parser;
if(!list) {
- play_tree_free(asx,1);
+ asx->free(1);
+ delete asx;
return NULL;
}
- play_tree_set_child(asx,list);
+ asx->set_child(list);
return asx;
}
} // namespace mpxp
Modified: mplayerxp/libplaytree/asxparser.h
===================================================================
--- mplayerxp/libplaytree/asxparser.h 2012-12-27 14:05:33 UTC (rev 607)
+++ mplayerxp/libplaytree/asxparser.h 2012-12-27 16:37:25 UTC (rev 608)
@@ -51,7 +51,7 @@
ASX_Parser();
virtual ~ASX_Parser();
- static play_tree_t* build_tree(libinput_t& libinput,const char* buffer, int ref);
+ static PlayTree* build_tree(libinput_t& libinput,const char* buffer, int ref);
virtual int parse_attribs(const char* buffer,ASX_Attrib& _attribs) const;
/*
@@ -60,13 +60,13 @@
virtual int get_element(const char** _buffer,ASX_Element& _attribs);
int get_line() const { return line; }
private:
- play_tree_t* repeat(libinput_t&libinput,const char* buffer,ASX_Attrib& _attribs);
+ PlayTree* repeat(libinput_t&libinput,const char* buffer,ASX_Attrib& _attribs);
void warning_attrib_required(const char *elem, const char *attr) const;
void warning_body_parse_error(const char *elem) const;
- void param(ASX_Attrib& attribs, play_tree_t* pt) const;
- void ref(ASX_Attrib& attribs, play_tree_t* pt) const;
- play_tree_t* entryref(libinput_t& libinput,const char* buffer,ASX_Attrib& _attribs) const;
- play_tree_t* entry(const char* buffer,ASX_Attrib& _attribs);
+ void param(ASX_Attrib& attribs, PlayTree* pt) const;
+ void ref(ASX_Attrib& attribs, PlayTree* pt) const;
+ PlayTree* entryref(libinput_t& libinput,const char* buffer,ASX_Attrib& _attribs) const;
+ PlayTree* entry(const char* buffer,ASX_Attrib& _attribs);
int line; // Curent line
ASX_LineSave_t* ret_stack;
Modified: mplayerxp/libplaytree/playtree.cpp
===================================================================
--- mplayerxp/libplaytree/playtree.cpp 2012-12-27 14:05:33 UTC (rev 607)
+++ mplayerxp/libplaytree/playtree.cpp 2012-12-27 16:37:25 UTC (rev 608)
@@ -13,168 +13,133 @@
#include "playtree.h"
#include "playtree_msg.h"
-static int
-play_tree_is_valid(play_tree_t* pt);
+namespace mpxp {
-play_tree_t*
-play_tree_new(void) {
- play_tree_t* r = (play_tree_t*)mp_calloc(1,sizeof(play_tree_t));
- if(r == NULL)
- mpxp_err<<"Can't allocate memory"<<std::endl;
- r->entry_type = PLAY_TREE_ENTRY_NODE;
- return r;
-}
+PlayTree::PlayTree()
+ :entry_type(PLAY_TREE_ENTRY_NODE) {}
+PlayTree::~PlayTree() {}
-void
-play_tree_free(play_tree_t* pt, int childs) {
- play_tree_t* iter;
+void PlayTree::free(int childs) {
+ PlayTree* iter;
- if(childs) {
- for(iter = pt->child; iter != NULL; ) {
- play_tree_t* nxt=iter->next;
- play_tree_free(iter,1);
- iter = nxt;
+ if(childs) {
+ for(iter = child; iter != NULL; ) {
+ PlayTree* nxt=iter->next;
+ iter->free(1);
+ delete iter;
+ iter = nxt;
+ }
+ child = NULL;
}
- pt->child = NULL;
- }
+ remove(0,0);
+ for(iter = child ; iter != NULL ; iter = iter->next) iter->parent = NULL;
+}
- play_tree_remove(pt,0,0);
+void PlayTree::free_list(int childs) {
+ PlayTree* iter;
- for(iter = pt->child ; iter != NULL ; iter = iter->next)
- iter->parent = NULL;
-
- delete pt;
+ for(iter = this ; iter->prev != NULL ; iter = iter->prev) /* NOTHING */;
+ while(iter) {
+ PlayTree* nxt = iter->next;
+ iter->free(childs);
+ delete iter;
+ iter = nxt;
+ }
}
-void
-play_tree_free_list(play_tree_t* pt, int childs) {
- play_tree_t* iter;
+MPXP_Rc PlayTree::is_valid() const {
+ PlayTree* iter;
- for(iter = pt ; iter->prev != NULL ; iter = iter->prev)
- /* NOTHING */;
-
- while(iter) {
- play_tree_t* nxt = iter->next;
- play_tree_free(iter, childs);
- iter = nxt;
- }
-
+ if(entry_type != PLAY_TREE_ENTRY_NODE) return MPXP_Ok;
+ else if (child != NULL) {
+ for(iter = child ; iter != NULL ; iter = iter->next) {
+ if(iter->is_valid()) return MPXP_Ok;
+ }
+ }
+ return MPXP_False;
}
-void
-play_tree_append_entry(play_tree_t* pt, play_tree_t* entry) {
- play_tree_t* iter;
+void PlayTree::append_entry(PlayTree* entry) {
+ PlayTree* iter;
- if(pt == entry)
- return;
+ if(this == entry) return;
- for(iter = pt ; iter->next != NULL ; iter = iter->next)
- /* NOTHING */;
+ for(iter = this; iter->next != NULL ; iter = iter->next) /* NOTHING */;
- entry->parent = iter->parent;
- entry->prev = iter;
- entry->next = NULL;
- iter->next = entry;
+ entry->parent = iter->parent;
+ entry->prev = iter;
+ entry->next = NULL;
+ iter->next = entry;
}
-void
-play_tree_prepend_entry(play_tree_t* pt, play_tree_t* entry) {
- play_tree_t* iter;
+void PlayTree::prepend_entry(PlayTree* entry) {
+ PlayTree* iter;
- for(iter = pt ; iter->prev != NULL; iter = iter->prev)
- /* NOTHING */;
+ for(iter = this ; iter->prev != NULL; iter = iter->prev) /* NOTHING */;
- entry->prev = NULL;
- entry->next = iter;
- entry->parent = iter->parent;
+ entry->prev = NULL;
+ entry->next = iter;
+ entry->parent = iter->parent;
- iter->prev = entry;
- if(entry->parent) {
- entry->parent->child = entry;
- }
+ iter->prev = entry;
+ if(entry->parent) entry->parent->child = entry;
}
-void
-play_tree_insert_entry(play_tree_t* pt, play_tree_t* entry) {
-
- entry->parent = pt->parent;
- entry->prev = pt;
- if(pt->next) {
- entry->next = pt->next;
- entry->next->prev = entry;
- } else
- entry->next = NULL;
- pt->next = entry;
-
+void PlayTree::insert_entry(PlayTree* entry) {
+ entry->parent = parent;
+ entry->prev = this;
+ if(next) {
+ entry->next = next;
+ entry->next->prev = entry;
+ } else entry->next = NULL;
+ next = entry;
}
-void
-play_tree_remove(play_tree_t* pt, int free_it,int with_childs) {
-
- // Middle of list
- if(pt->prev && pt->next) {
- pt->prev->next = pt->next;
- pt->next->prev = pt->prev;
- } // End of list
- else if(pt->prev) {
- pt->prev->next = NULL;
- } // Begining of list
- else if(pt->next) {
- pt->next->prev = NULL;
- if(pt->parent) {
- pt->parent->child = pt->next;
+void PlayTree::remove(int free_it,int with_childs) {
+ // Middle of list
+ if(prev && next) {
+ prev->next = next;
+ next->prev = prev;
+ } // End of list
+ else if(prev) {
+ prev->next = NULL;
+ } // Begining of list
+ else if(next) {
+ next->prev = NULL;
+ if(parent) parent->child = next;
+ } // The only one
+ else if(parent) {
+ parent->child = NULL;
}
- } // The only one
- else if(pt->parent) {
- pt->parent->child = NULL;
- }
-
- pt->prev = pt->next = pt->parent = NULL;
- if(free_it)
- play_tree_free(pt,with_childs);
-
+ prev = next = parent = NULL;
+ if(free_it) free(with_childs);
}
-void
-play_tree_set_child(play_tree_t* pt, play_tree_t* child) {
- play_tree_t* iter;
+void PlayTree::set_child(PlayTree* _child) {
+ PlayTree* iter;
- for(iter = pt->child ; iter != NULL ; iter = iter->next)
- iter->parent = NULL;
-
- // Go back to first one
- for(iter = child ; iter->prev != NULL ; iter = iter->prev)
- /* NOTHING */;
-
- pt->child = iter;
-
- for( ; iter != NULL ; iter= iter->next)
- iter->parent = pt;
-
+ for(iter = _child ; iter != NULL ; iter = iter->next) iter->parent = NULL;
+ // Go back to first one
+ for(iter = _child ; iter->prev != NULL ; iter = iter->prev) /* NOTHING */;
+ child = iter;
+ for( ; iter != NULL ; iter= iter->next) iter->parent = this;
}
-void
-play_tree_set_parent(play_tree_t* pt, play_tree_t* parent) {
- play_tree_t* iter;
+void PlayTree::set_parent(PlayTree* _parent) {
+ PlayTree* iter;
- if(pt->parent)
- pt->parent->child = NULL;
-
- for(iter = pt ; iter != NULL ; iter = iter->next)
- iter->parent = parent;
-
- if(pt->prev) {
- for(iter = pt->prev ; iter->prev != NULL ; iter = iter->prev)
- iter->parent = parent;
- iter->parent = parent;
- parent->child = iter;
- } else
- parent->child = pt;
+ if(_parent) _parent->child = NULL;
+ for(iter = this ; iter != NULL ; iter = iter->next) iter->parent = _parent;
+ if(prev) {
+ for(iter = prev ; iter->prev != NULL ; iter = iter->prev) iter->parent = _parent;
+ iter->parent=_parent;
+ _parent->child=iter;
+ } else _parent->child = this;
}
-void play_tree_add_file(play_tree_t* pt,const std::string& file) {
- if(pt->entry_type != PLAY_TREE_ENTRY_NODE &&
- pt->entry_type != PLAY_TREE_ENTRY_FILE)
+void PlayTree::add_file(const std::string& file) {
+ if(entry_type != PLAY_TREE_ENTRY_NODE &&
+ entry_type != PLAY_TREE_ENTRY_FILE)
return;
size_t pos;
@@ -182,131 +147,156 @@
std::transform(lf.begin(),lf.end(),lf.begin(), ::tolower);
if(lf.substr(0,6)=="vcd://") {
- pt->entry_type = PLAY_TREE_ENTRY_VCD;
+ entry_type = PLAY_TREE_ENTRY_VCD;
pos=6;
} else if(lf.substr(0,6)=="dvd://") {
- pt->entry_type = PLAY_TREE_ENTRY_DVD;
+ entry_type = PLAY_TREE_ENTRY_DVD;
pos=6;
} else if(lf.substr(0,5)=="tv://") {
- pt->entry_type = PLAY_TREE_ENTRY_TV;
+ entry_type = PLAY_TREE_ENTRY_TV;
pos=5;
} else {
- pt->entry_type = PLAY_TREE_ENTRY_FILE;
+ entry_type = PLAY_TREE_ENTRY_FILE;
pos=0;
}
tail=file.substr(pos);
- pt->files.push_back(tail);
+ files.push_back(tail);
}
-MPXP_Rc play_tree_remove_file(play_tree_t* pt,const std::string& file) {
+MPXP_Rc PlayTree::remove_file(const std::string& file) {
int f = -1;
- size_t n,sz=pt->files.size();
+ size_t n,sz=files.size();
- for(n=0; n<sz; n++) if(file==pt->files[n]) f = n;
+ for(n=0; n<sz; n++) if(file==files[n]) f = n;
if(f < 0) return MPXP_False; // Not found
- pt->files.erase(pt->files.begin()+f);
+ files.erase(files.begin()+f);
return MPXP_Ok;
}
-void play_tree_set_param(play_tree_t* pt,const std::string& name,const std::string& val) {
+void PlayTree::set_param(const std::string& name,const std::string& val) {
int ni = -1;
- size_t n,sz=pt->params.size();
+ size_t n,sz=params.size();
std::string lname=name;
std::transform(lname.begin(),lname.end(),lname.begin(), ::tolower);
- if(!pt->params.empty()) {
+ if(!params.empty()) {
for(n=0; n<sz; n++) {
- std::string lparm=pt->params[n].name;
+ std::string lparm=params[n].name;
std::transform(lparm.begin(),lparm.end(),lparm.begin(), ::tolower);
if(lname==lparm) ni = n;
}
}
if(ni > 0) {
- pt->params[ni].value = val;
+ params[ni].value = val;
return;
}
play_tree_param_t param;
param.name=name;
param.value=val;
- pt->params.push_back(param);
+ params.push_back(param);
}
-MPXP_Rc play_tree_unset_param(play_tree_t* pt,const std::string& name) {
+MPXP_Rc PlayTree::unset_param(const std::string& name) {
int ni = -1;
- size_t n,sz=pt->params.size();
+ size_t n,sz=params.size();
std::string lname=name;
std::transform(lname.begin(),lname.end(),lname.begin(), ::tolower);
for(n=0;n<sz;n++) {
- std::string lparm=pt->params[n].name;
+ std::string lparm=params[n].name;
std::transform(lparm.begin(),lparm.end(),lparm.begin(), ::tolower);
if(lname==lparm) ni = n;
}
if(ni < 0) return MPXP_False;
- if(n > 1) pt->params.erase(pt->params.begin()+ni);
- else pt->params.clear();
+ if(n > 1) params.erase(params.begin()+ni);
+ else params.clear();
return MPXP_Ok;
}
-void play_tree_set_params_from(play_tree_t* dest,const play_tree_t* src) {
- size_t i,sz=src->params.size();
+void PlayTree::set_params_from(const PlayTree& src) {
+ size_t i,sz=src.params.size();
- if(src->params.empty()) return;
+ if(src.params.empty()) return;
for(i=0;i<sz; i++)
- play_tree_set_param(dest,src->params[i].name,src->params[i].value);
- if(src->flags & PLAY_TREE_RND) // pass the random flag too
- dest->flags |= PLAY_TREE_RND;
+ set_param(src.params[i].name,src.params[i].value);
+ if(src.flags & PLAY_TREE_RND) // pass the random flag too
+ flags |= PLAY_TREE_RND;
}
// all children if deep < 0
-void play_tree_set_flag(play_tree_t* pt, int flags , int deep) {
- play_tree_t* i;
+void PlayTree::set_flag(int _flags, int deep) {
+ PlayTree* i;
- pt->flags |= flags;
+ flags |= _flags;
- if(deep && pt->child) {
- if(deep > 0) deep--;
- for(i = pt->child ; i ; i = i->next)
- play_tree_set_flag(i,flags,deep);
- }
+ if(deep && child) {
+ if(deep > 0) deep--;
+ for(i = child ; i ; i = i->get_next()) i->set_flag(_flags,deep);
+ }
}
-void play_tree_unset_flag(play_tree_t* pt, int flags , int deep) {
- play_tree_t* i;
+void PlayTree::unset_flag(int _flags, int deep) {
+ PlayTree* i;
- pt->flags &= ~flags;
+ flags &= ~_flags;
- if(deep && pt->child) {
- if(deep > 0) deep--;
- for(i = pt->child ; i ; i = i->next)
- play_tree_unset_flag(i,flags,deep);
- }
+ if(deep && child) {
+ if(deep > 0) deep--;
+ for(i = child ; i ; i = i->get_next()) i->unset_flag(_flags,deep);
+ }
}
-static play_tree_t*
-play_tree_rnd_step(play_tree_t* pt) {
+MPXP_Rc PlayTree::cleanup() {
+ PlayTree* iter, *tmp, *first;
+
+ if( ! is_valid()) {
+ remove(1,1);
+ return MPXP_False;
+ }
+
+ first = child;
+
+ for(iter = child ; iter != NULL ; ) {
+ tmp = iter;
+ iter = iter->next;
+ if(! tmp->is_valid()) {
+ tmp->remove(1,1);
+ if(tmp == first) first = iter;
+ }
+ }
+
+ for(iter = first ; iter != NULL ; ) {
+ tmp = iter;
+ iter = iter->next;
+ tmp->cleanup();
+ }
+ return MPXP_Ok;
+}
+
+static PlayTree*
+play_tree_rnd_step(PlayTree* pt) {
int count = 0;
int r,rnd;
time_t tim;
- play_tree_t *i,*head;
+ PlayTree *i,*head;
// Count how many mp_free choice we have
- for(i = pt ; i->prev ; i = i->prev)
- if(!(i->flags & PLAY_TREE_RND_PLAYED)) count++;
+ for(i = pt ; i->get_prev() ; i = i->get_prev())
+ if(!(i->get_flags() & PLAY_TREE_RND_PLAYED)) count++;
head = i;
- if(!(i->flags & PLAY_TREE_RND_PLAYED)) count++;
- if(pt->next)
- for(i = pt->next ; i ; i = i->next)
- if(!(i->flags & PLAY_TREE_RND_PLAYED)) count++;
+ if(!(i->get_flags() & PLAY_TREE_RND_PLAYED)) count++;
+ if(pt->get_next())
+ for(i = pt->get_next() ; i ; i = i->get_next())
+ if(!(i->get_flags() & PLAY_TREE_RND_PLAYED)) count++;
if(!count) return NULL;
/* make it time depended */
@@ -316,24 +306,23 @@
r = (int)(((float)(count) * rnd) / (RAND_MAX + 1.0));
if(r) rnd = r = count - (tim%r);
- for(i = head ; i ; i=i->next) {
- if(!(i->flags & PLAY_TREE_RND_PLAYED)) r--;
+ for(i = head ; i ; i=i->get_next()) {
+ if(!(i->get_flags() & PLAY_TREE_RND_PLAYED)) r--;
if(r < 0) return i;
}
- for(i = head ; i ; i=i->next) {
- if(!(i->flags & PLAY_TREE_RND_PLAYED)) return i;
+ for(i = head ; i ; i=i->get_next()) {
+ if(!(i->get_flags() & PLAY_TREE_RND_PLAYED)) return i;
}
mpxp_err<<"Random stepping error r="<<rnd<<std::endl;
return NULL;
}
-namespace mpxp {
-_PlayTree_Iter::_PlayTree_Iter(play_tree_t* pt,m_config_t& _config)
+_PlayTree_Iter::_PlayTree_Iter(PlayTree* pt,m_config_t& _config)
:root(pt),
tree(NULL),
config(_config) {
- if(pt->parent) loop = pt->parent->loop;
+ if(pt->get_parent()) loop = pt->get_parent()->get_loop();
}
_PlayTree_Iter::_PlayTree_Iter(const _PlayTree_Iter& old)
@@ -348,7 +337,7 @@
_PlayTree_Iter::~_PlayTree_Iter() {}
void _PlayTree_Iter::push_params() {
- play_tree_t* pt;
+ PlayTree* pt;
pt = tree;
@@ -356,21 +345,21 @@
// while playing
m_config_push(config);
- if(pt->params.empty()) return;
- size_t n,sz=pt->params.size();
+ if(pt->get_params().empty()) return;
+ size_t n,sz=pt->get_params().size();
for(n=0; n<sz; n++) {
int e;
- if((e = m_config_set_option(config,pt->params[n].name,pt->params[n].value)) < 0)
- mpxp_err<<"Error "<<e<<" while setting option '"<<pt->params[n].name<<"' with value '"<<pt->params[n].value<<"'"<<std::endl;
+ if((e = m_config_set_option(config,pt->get_param(n).name,pt->get_param(n).value)) < 0)
+ mpxp_err<<"Error "<<e<<" while setting option '"<<pt->get_param(n).name<<"' with value '"<<pt->get_param(n).value<<"'"<<std::endl;
}
- if(!pt->child) entry_pushed = 1;
+ if(!pt->get_child()) entry_pushed = 1;
return;
}
int _PlayTree_Iter::step(int d,int with_nodes) {
- play_tree_t* pt;
+ PlayTree* pt;
int rnd;
if(tree == NULL) {
@@ -383,7 +372,7 @@
m_config_pop(config);
}
- if(tree->parent && (tree->parent->flags & PLAY_TREE_RND))
+ if(tree->get_parent() && (tree->get_parent()->get_flags() & PLAY_TREE_RND))
rnd=mode = PLAY_TREE_ITER_RND;
else
rnd=mode = PLAY_TREE_ITER_NORMAL;
@@ -393,30 +382,30 @@
else if( d > 0 ) {
int i;
pt = tree;
- for(i = d ; i > 0 && pt ; i--) pt = pt->next;
+ for(i = d ; i > 0 && pt ; i--) pt = pt->get_next();
d = i ? i : 1;
} else if(d < 0) {
int i;
pt = tree;
- for(i = d ; i < 0 && pt ; i++) pt = pt->prev;
+ for(i = d ; i < 0 && pt ; i++) pt = pt->get_prev();
d = i ? i : -1;
} else pt = tree;
if(pt == NULL) { // No next
// Must we loop?
if (mode == PLAY_TREE_ITER_RND) {
- if (root->loop == 0) return PLAY_TREE_ITER_END;
- play_tree_unset_flag(root, PLAY_TREE_RND_PLAYED, -1);
- if (root->loop > 0) root->loop--;
+ if (root->get_loop() == 0) return PLAY_TREE_ITER_END;
+ root->unset_flag(PLAY_TREE_RND_PLAYED, -1);
+ if (root->get_loop() > 0) root->set_loop(root->get_loop()-1);
// try again
return step(0, with_nodes);
- } else if(tree->parent && tree->parent->loop != 0 && ((d > 0 && loop != 0) || ( d < 0 && (loop < 0 || loop < tree->parent->loop)))) {
+ } else if(tree->get_parent() && tree->get_parent()->get_loop() != 0 && ((d > 0 && loop != 0) || ( d < 0 && (loop < 0 || loop < tree->get_parent()->get_loop())))) {
if(d > 0) { // Go back to the first one
- for(pt = tree ; pt->prev != NULL; pt = pt->prev) /* NOTHNG */;
+ for(pt = tree ; pt->get_prev() != NULL; pt = pt->get_prev()) /* NOTHNG */;
if(loop > 0) loop--;
} else if( d < 0 ) { // Or the last one
- for(pt = tree ; pt->next != NULL; pt = pt->next) /* NOTHNG */;
- if(loop >= 0 && loop < tree->parent->loop) loop++;
+ for(pt = tree ; pt->get_next() != NULL; pt = pt->get_next()) /* NOTHNG */;
+ if(loop >= 0 && loop < tree->get_parent()->get_loop()) loop++;
}
tree = pt;
return step(0,with_nodes);
@@ -425,7 +414,7 @@
return up_step(d,with_nodes);
}
// Is there any valid child?
- if(pt->child && play_tree_is_valid(pt->child)) {
+ if(pt->get_child() && pt->get_child()->is_valid()) {
tree = pt;
if(with_nodes) { // Stop on the node
return PLAY_TREE_ITER_NODE;
@@ -433,7 +422,7 @@
return down_step(d,with_nodes);
}
// Is it a valid entry?
- if(! play_tree_is_valid(pt)) {
+ if(! pt->is_valid()) {
if(d == 0 && rnd==PLAY_TREE_ITER_NORMAL) { // Can this happen ? FF: Yes!
mpxp_err<<"What to do now ???? Infinite loop if we continue"<<std::endl;
return PLAY_TREE_ITER_ERROR;
@@ -443,25 +432,25 @@
tree = pt;
- num_files = tree->files.size();
+ num_files = tree->get_files().size();
push_params();
entry_pushed = 1;
- if(mode == PLAY_TREE_ITER_RND) pt->flags |= PLAY_TREE_RND_PLAYED;
+ if(mode == PLAY_TREE_ITER_RND) pt->set_flags(pt->get_flags()|PLAY_TREE_RND_PLAYED);
return PLAY_TREE_ITER_ENTRY;
}
int _PlayTree_Iter::up_step(int d,int with_nodes) {
file = -1;
- if(tree->parent == root->parent) return PLAY_TREE_ITER_END;
+ if(tree->get_parent() == root->get_parent()) return PLAY_TREE_ITER_END;
loop = status_stack.top(); status_stack.pop();
- tree = tree->parent;
+ tree = tree->get_parent();
// Pop subtree params
m_config_pop(config);
- if(mode == PLAY_TREE_ITER_RND) tree->flags |= PLAY_TREE_RND_PLAYED;
+ if(mode == PLAY_TREE_ITER_RND) tree->set_flags(tree->get_flags()|PLAY_TREE_RND_PLAYED);
return step(d,with_nodes);
}
@@ -473,11 +462,11 @@
status_stack.push(loop);
// Set new status
- loop = tree->loop-1;
- if(d >= 0) tree = tree->child;
+ loop = tree->get_loop()-1;
+ if(d >= 0) tree = tree->get_child();
else {
- play_tree_t* pt;
- for(pt = tree->child ; pt->next != NULL ; pt = pt->next) /*NOTING*/;
+ PlayTree* pt;
+ for(pt = tree->get_child() ; pt->get_next() != NULL ; pt = pt->get_next()) /*NOTING*/;
tree = pt;
}
return step(0,with_nodes);
@@ -486,7 +475,7 @@
std::string _PlayTree_Iter::get_file(int d) {
std::string entry;
- if(tree->files.empty()) return "";
+ if(tree->get_files().empty()) return "";
if(file >= num_files-1 || file < -1) return "";
if(d > 0) {
if(file >= num_files - 1) file = 0;
@@ -495,9 +484,9 @@
if(file <= 0) file = num_files - 1;
else file--;
}
- entry = tree->files[file];
+ entry = tree->get_file(file);
- switch(tree->entry_type) {
+ switch(tree->get_entry_type()) {
case PLAY_TREE_ENTRY_DVD :
if(entry.length() == 0) entry = "1";
m_config_set_option(config,"dvd",entry);
@@ -531,73 +520,6 @@
} // namespace mpxp
-
-static int
-play_tree_is_valid(play_tree_t* pt) {
- play_tree_t* iter;
-
- if(pt->entry_type != PLAY_TREE_ENTRY_NODE) {
- return 1;
- }
- else if (pt->child != NULL) {
- for(iter = pt->child ; iter != NULL ; iter = iter->next) {
- if(play_tree_is_valid(iter))
- return 1;
- }
- }
- return 0;
-}
-
-play_tree_t*
-play_tree_cleanup(play_tree_t* pt) {
- play_tree_t* iter, *tmp, *first;
-
- if( ! play_tree_is_valid(pt)) {
- play_tree_remove(pt,1,1);
- return NULL;
- }
-
- first = pt->child;
-
- for(iter = pt->child ; iter != NULL ; ) {
- tmp = iter;
- iter = iter->next;
- if(! play_tree_is_valid(tmp)) {
- play_tree_remove(tmp,1,1);
- if(tmp == first) first = iter;
- }
- }
-
- for(iter = first ; iter != NULL ; ) {
- tmp = iter;
- iter = iter->next;
- play_tree_cleanup(tmp);
- }
-
- return pt;
-
-}
-
-// HIGH Level API, by Fabian Franz (mp...@fa...)
-//
-_PlayTree_Iter* pt_iter_create(play_tree_t** ppt, m_config_t& config)
-{
- _PlayTree_Iter* r=NULL;
-
- *ppt=play_tree_cleanup(*ppt);
-
- if(*ppt) {
- r = new _PlayTree_Iter(*ppt,config);
- if (r && r->step(0,0) != PLAY_TREE_ITER_ENTRY)
- {
- delete r;
- r = NULL;
- }
- }
-
- return r;
-}
-
void pt_iter_destroy(_PlayTree_Iter** iter)
{
if (iter && *iter)
@@ -627,40 +549,40 @@
return r;
}
-void pt_iter_insert_entry(_PlayTree_Iter* iter, play_tree_t* entry)
+void pt_iter_insert_entry(_PlayTree_Iter* iter, PlayTree* entry)
{
- play_tree_t *pt = iter->get_tree();
+ PlayTree *pt = iter->get_tree();
- play_tree_insert_entry(pt, entry);
- play_tree_set_params_from(entry,pt);
+ pt->insert_entry(entry);
+ entry->set_params_from(*pt);
}
-void pt_iter_replace_entry(_PlayTree_Iter* iter, play_tree_t* entry)
+void pt_iter_replace_entry(_PlayTree_Iter* iter, PlayTree* entry)
{
- play_tree_t *pt = iter->get_tree();
+ PlayTree *pt = iter->get_tree();
pt_iter_insert_entry(iter, entry);
- play_tree_remove(pt, 1, 1);
+ pt->remove(1, 1);
iter->set_tree(entry);
}
//Add a new file as a new entry
-void pt_add_file(play_tree_t** ppt,const std::string& filename)
+void pt_add_file(PlayTree** ppt,const std::string& filename)
{
- play_tree_t *pt = *ppt, *entry = play_tree_new();
+ PlayTree *pt = *ppt, *entry = new(zeromem) PlayTree;
- play_tree_add_file(entry, filename);
+ entry->add_file(filename);
if (pt)
- play_tree_append_entry(pt, entry);
+ pt->append_entry(entry);
else
{
pt=entry;
*ppt=pt;
}
- play_tree_set_params_from(entry,pt);
+ entry->set_params_from(*pt);
}
-void pt_add_gui_file(play_tree_t** ppt,const std::string& path,const std::string& file)
+void pt_add_gui_file(PlayTree** ppt,const std::string& path,const std::string& file)
{
std::string wholename;
Modified: mplayerxp/libplaytree/playtree.h
===================================================================
--- mplayerxp/libplaytree/playtree.h 2012-12-27 14:05:33 UTC (rev 607)
+++ mplayerxp/libplaytree/playtree.h 2012-12-27 16:37:25 UTC (rev 608)
@@ -44,29 +44,75 @@
/// \defgroup Playtree
///@{
-struct play_tree_param_t {
- std::string name;
- std::string value;
-};
+namespace mpxp {
+ struct play_tree_param_t {
+ std::string name;
+ std::string value;
+ };
-struct play_tree_t {
- play_tree_t* parent;
- play_tree_t* child;
- play_tree_t* next;
- play_tree_t* prev;
+ class PlayTree : public Opaque {
+ public:
+ PlayTree();
+ virtual ~PlayTree();
- //play_tree_info_t info;
- std::vector<play_tree_param_t> params;
- int loop;
- std::vector<std::string> files;
- int entry_type;
- int flags;
-};
+ static PlayTree* parse_playtree(libinput_t& libinput,Stream* stream);
+ static PlayTree* parse_playlist_file(libinput_t&libinput,const std::string& file);
+ virtual MPXP_Rc cleanup();
+ // If childs is true mp_free also the childs
+ virtual void free(int childs);
+ virtual void free_list(int childs);
-namespace mpxp {
+ virtual void set_child(PlayTree* child);
+ virtual void set_parent(PlayTree* parent);
+ // Add at end
+ virtual void append_entry(PlayTree* entry);
+ // And on begining
+ virtual void prepend_entry(PlayTree* entry);
+ // Insert after
+ virtual void insert_entry(PlayTree* entry);
+ // Detach from the tree
+ virtual void remove(int free_it,int with_childs);
+ virtual void add_file(const std::string& file);
+ virtual MPXP_Rc remove_file(const std::string& file);
+ virtual void set_param(const std::string& name,const std::string& val);
+ virtual MPXP_Rc unset_param(const std::string& name);
+ /// Copy the config parameters from one item to another.
+ virtual void set_params_from(const PlayTree& src);
+ virtual void set_flag(int flags, int deep);
+ virtual void unset_flag(int flags, int deep);
+ virtual MPXP_Rc is_valid() const;
+
+ PlayTree* get_parent() const { return parent; }
+ PlayTree* get_child() const { return child; }
+ PlayTree* get_prev() const { return prev; }
+ PlayTree* get_next() const { return next; }
+ void set_prev(PlayTree* p) { prev=p; }
+ void set_next(PlayTree* p) { next=p; }
+ const std::string& get_file(size_t idx) const { return files[idx]; }
+ const std::vector<std::string>& get_files() const { return files; }
+ const play_tree_param_t& get_param(size_t idx) const { return params[idx]; }
+ const std::vector<play_tree_param_t>&get_params() const { return params; }
+ int get_entry_type() const { return entry_type; }
+ int get_loop() const { return loop; }
+ void set_loop(int l) { loop=l; }
+ int get_flags() const { return flags; }
+ void set_flags(int f) { flags=f; }
+ private:
+ PlayTree* parent;
+ PlayTree* child;
+ PlayTree* next;
+ PlayTree* prev;
+
+ std::vector<play_tree_param_t> params;
+ int loop;
+ std::vector<std::string> files;
+ int entry_type;
+ int flags;
+ };
+
struct _PlayTree_Iter : public Opaque {
public:
- _PlayTree_Iter(play_tree_t* parent,m_config_t& config);
+ _PlayTree_Iter(PlayTree* parent,m_config_t& config);
_PlayTree_Iter(const _PlayTree_Iter& old);
virtual ~_PlayTree_Iter();
@@ -79,16 +125,16 @@
virtual int down_step(int d,int with_nodes);
virtual std::string get_file(int d);
- play_tree_t* get_root() const { return root; }
- play_tree_t* get_tree() const { return tree; }
- void set_tree(play_tree_t* _tree) { tree=_tree; }
+ PlayTree* get_root() const { return root; }
+ PlayTree* get_tree() const { return tree; }
+ void set_tree(PlayTree* _tree) { tree=_tree; }
void reset_tree() { tree=root; }
int get_file() const { return file; }
int get_num_files() const { return num_files; }
private:
void push_params();
- play_tree_t* root; // Iter root tree
- play_tree_t* tree; // Current tree
+ PlayTree* root; // Iter root tree
+ PlayTree* tree; // Current tree
m_config_t& config;
int loop; // Looping status
int file;
@@ -99,72 +145,13 @@
std::stack<int> status_stack;
};
} // namespace mpxp
-play_tree_t* parse_playtree(libinput_t& libinput,Stream* stream);
-play_tree_t* play_tree_cleanup(play_tree_t* pt);
-
-play_tree_t* parse_playlist_file(libinput_t&libinput,const std::string& file);
-
-play_tree_t* play_tree_new(void);
-
-// If childs is true mp_free also the childs
-void
-play_tree_free(play_tree_t* pt, int childs);
-
-
-void
-play_tree_free_list(play_tree_t* pt, int childs);
-
-
-// Childs
-void
-play_tree_set_child(play_tree_t* pt, play_tree_t* child);
-// Or parent
-void
-play_tree_set_parent(play_tree_t* pt, play_tree_t* parent);
-
-
-// Add at end
-void
-play_tree_append_entry(play_tree_t* pt, play_tree_t* entry);
-
-// And on begining
-void
-play_tree_prepend_entry(play_tree_t* pt, play_tree_t* entry);
-
-// Insert after
-void
-play_tree_insert_entry(play_tree_t* pt, play_tree_t* entry);
-
-// Detach from the tree
-void
-play_tree_remove(play_tree_t* pt, int free_it,int with_childs);
-
-
-void
-play_tree_add_file(play_tree_t* pt,const std::string& file);
-
-MPXP_Rc play_tree_remove_file(play_tree_t* pt,const std::string& file);
-
-// Val can be NULL
-void
-play_tree_set_param(play_tree_t* pt,const std::string& name,const std::string& val);
-
-MPXP_Rc play_tree_unset_param(play_tree_t* pt,const std::string& name);
-/// Copy the config parameters from one item to another.
-void
-play_tree_set_params_from(play_tree_t* dest,const play_tree_t* src);
-
-
/// \defgroup PtAPI Playtree highlevel API
/// \ingroup Playtree
/// Highlevel API with pt-suffix to different from low-level API
/// by Fabian Franz (mp...@fa...).
///@{
-// Cleans up pt and creates a new iter.
-_PlayTree_Iter* pt_iter_create(play_tree_t** pt, struct m_config* config);
-
/// Frees the iter.
void pt_iter_destroy(_PlayTree_Iter** iter);
@@ -176,21 +163,21 @@
static inline std::string pt_iter_get_prev_file(_PlayTree_Iter* iter) { return pt_iter_get_file(iter, -1); }
/// Inserts entry into the playtree.
-void pt_iter_insert_entry(_PlayTree_Iter* iter, play_tree_t* entry);
+void pt_iter_insert_entry(_PlayTree_Iter* iter, PlayTree* entry);
/// Replaces current entry in playtree with entry by doing insert and remove.
-void pt_iter_replace_entry(_PlayTree_Iter* iter, play_tree_t* entry);
+void pt_iter_replace_entry(_PlayTree_Iter* iter, PlayTree* entry);
/// Adds a new file to the playtree, if it is not valid it is created.
-void pt_add_file(play_tree_t** ppt,const std::string& filename);
+void pt_add_file(PlayTree** ppt,const std::string& filename);
/// \brief Performs a convert to playtree-syntax, by concat path/file
/// and performs pt_add_file
-void pt_add_gui_file(play_tree_t** ppt,const std::string& path,const std::string& file);
+void pt_add_gui_file(PlayTree** ppt,const std::string& path,const std::string& file);
// Two macros to use only the iter and not the other things.
-static inline void pt_iter_add_file(_PlayTree_Iter* iter, const std::string& filename) { play_tree_t* tree=iter->get_tree(); pt_add_file(&tree, filename); }
-static inline void pt_iter_add_gui_file(_PlayTree_Iter* iter,const std::string& path,const std::string& name) { play_tree_t* tree=iter->get_tree(); pt_add_gui_file(&tree, path, name); }
+static inline void pt_iter_add_file(_PlayTree_Iter* iter, const std::string& filename) { PlayTree* tree=iter->get_tree(); pt_add_file(&tree, filename); }
+static inline void pt_iter_add_gui_file(_PlayTree_Iter* iter,const std::string& path,const std::string& name) { PlayTree* tree=iter->get_tree(); pt_add_gui_file(&tree, path, name); }
/// Resets the iter and goes back to head.
void pt_iter_goto_head(_PlayTree_Iter* iter);
Modified: mplayerxp/libplaytree/playtreeparser.cpp
===================================================================
--- mplayerxp/libplaytree/playtreeparser.cpp 2012-12-27 14:05:33 UTC (rev 607)
+++ mplayerxp/libplaytree/playtreeparser.cpp 2012-12-27 16:37:25 UTC (rev 608)
@@ -116,7 +116,7 @@
}
-static play_tree_t* parse_asx(libinput_t& libinput,play_tree_parser_t* p) {
+static PlayTree* parse_asx(libinput_t& libinput,play_tree_parser_t* p) {
int comments = 0,get_line = 1;
char* line = NULL;
@@ -224,12 +224,12 @@
}
-play_tree_t*
+PlayTree*
parse_pls(play_tree_parser_t* p) {
char *line,*v;
pls_entry_t* entries = NULL;
int n_entries = 0,max_entry=0,num;
- play_tree_t *list = NULL, *entry = NULL;
+ PlayTree *list = NULL, *entry = NULL;
mpxp_v<<"Trying winamp playlist..."<<std::endl;
line = play_tree_parser_get_line(p);
@@ -286,11 +286,11 @@
mpxp_err<<"Entry "<<(num+1)<<" don't have a file !!!!"<<std::endl;
else {
mpxp_dbg2<<"Adding entry "<<entries[num].file<<std::endl;
- entry = play_tree_new();
- play_tree_add_file(entry,entries[num].file);
+ entry = new(zeromem) PlayTree;
+ entry->add_file(entries[num].file);
delete entries[num].file;
if(list)
- play_tree_append_entry(list,entry);
+ list->append_entry(entry);
else
list = entry;
}
@@ -306,15 +306,15 @@
delete entries;
- entry = play_tree_new();
- play_tree_set_child(entry,list);
+ entry = new(zeromem) PlayTree;
+ entry->set_child(list);
return entry;
}
-play_tree_t*
+PlayTree*
parse_textplain(play_tree_parser_t* p) {
char* line;
- play_tree_t *list = NULL, *entry = NULL;
+ PlayTree *list = NULL, *entry = NULL;
mpxp_v<<"Trying plaintext..."<<std::endl;
play_tree_parser_stop_keeping(p);
@@ -323,23 +323,24 @@
strstrip(line);
if(line[0] == '\0')
continue;
- entry = play_tree_new();
- play_tree_add_file(entry,line);
+ entry = new(zeromem) PlayTree;
+ entry->add_file(line);
if(!list)
list = entry;
else
- play_tree_append_entry(list,entry);
+ list->append_entry(entry);
}
if(!list) return NULL;
- entry = play_tree_new();
- play_tree_set_child(entry,list);
+ entry = new(zeromem) PlayTree;
+ entry->set_child(list);
return entry;
}
-play_tree_t* parse_playtree(libinput_t&libinput,Stream* stream) {
+namespace mpxp {
+PlayTree* PlayTree::parse_playtree(libinput_t&libinput,Stream* stream) {
play_tree_parser_t* p;
- play_tree_t* ret;
+ PlayTree* ret;
p = play_tree_parser_new(stream,0);
if(!p)
@@ -351,9 +352,9 @@
return ret;
}
-play_tree_t* parse_playlist_file(libinput_t&libinput,const std::string& file) {
+PlayTree* PlayTree::parse_playlist_file(libinput_t&libinput,const std::string& file) {
Stream *stream;
- play_tree_t* ret;
+ PlayTree* ret;
int ff;
mpxp_v<<"Parsing playlist file "<<file<<"..."<<std::endl;
@@ -361,12 +362,12 @@
stream = new(zeromem) Stream;
stream->open(libinput,file,&ff);
stream->type(Stream::Type_Text);
- ret = parse_playtree(libinput,stream);
+ ret = PlayTree::parse_playtree(libinput,stream);
delete stream;
return ret;
-
}
+} // namespace mpxp
play_tree_parser_t* play_tree_parser_new(Stream* stream,int deep) {
play_tree_parser_t* p;
@@ -390,9 +391,9 @@
delete p;
}
-play_tree_t*
+PlayTree*
play_tree_parser_get_play_tree(libinput_t& libinput,play_tree_parser_t* p) {
- play_tree_t* tree = NULL;
+ PlayTree* tree = NULL;
while(play_tree_parser_get_line(p) != NULL) {
play_tree_parser_reset(p);
@@ -415,10 +416,7 @@
mpxp_v<<"Playlist succefully parsed"<<std::endl;
else mpxp_err<<"Error while parsing playlist"<<std::endl;
- if(tree)
- tree = play_tree_cleanup(tree);
+ if(tree->cleanup()!=MPXP_Ok) mpxp_warn<<"Warning empty playlist"<<std::endl;
- if(!tree) mpxp_warn<<"Warning empty playlist"<<std::endl;
-
return tree;
}
Modified: mplayerxp/libplaytree/playtreeparser.h
===================================================================
--- mplayerxp/libplaytree/playtreeparser.h 2012-12-27 14:05:33 UTC (rev 607)
+++ mplayerxp/libplaytree/playtreeparser.h 2012-12-27 16:37:25 UTC (rev 608)
@@ -14,6 +14,6 @@
void play_tree_parser_free(play_tree_parser_t* p);
-play_tree_t* play_tree_parser_get_play_tree(libinput_t&libinput,play_tree_parser_t* p);
+PlayTree* play_tree_parser_get_play_tree(libinput_t&libinput,play_tree_parser_t* p);
#endif
Modified: mplayerxp/mplayerxp.cpp
===================================================================
--- mplayerxp/mplayerxp.cpp 2012-12-27 14:05:33 UTC (rev 607)
+++ mplayerxp/mplayerxp.cpp 2012-12-27 16:37:25 UTC (rev 608)
@@ -154,7 +154,7 @@
MPXP_Rc ao_inited;
int osd_show_framedrop;
int osd_function;
- play_tree_t* playtree;
+ PlayTree* playtree;
// for multifile support:
_PlayTree_Iter* playtree_iter;
private:
@@ -935,11 +935,11 @@
int MPXPSystem::handle_playlist(const std::string& filename) const {
Stream* stream=static_cast<Stream*>(_demuxer->stream);
int eof=0;
- play_tree_t* entry;
+ PlayTree* entry;
// Handle playlist
MP_UNIT("handle_playlist");
mpxp_v<<"Parsing playlist "<<filename<<"..."<<std::endl;
- entry = parse_playtree(_libinput,stream);
+ entry = PlayTree::parse_playtree(_libinput,stream);
if(!entry) {
entry = playtree_iter->get_tree();
if(playtree_iter->step(1,0) != PLAY_TREE_ITER_ENTRY) {
@@ -952,17 +952,17 @@
return eof;
}
}
- play_tree_remove(entry,1,1);
+ entry->remove(1,1);
eof = PT_NEXT_SRC;
return eof;
}
- play_tree_insert_entry(playtree_iter->get_tree(),entry);
+ playtree_iter->get_tree()->insert_entry(entry);
entry = playtree_iter->get_tree();
if(playtree_iter->step(1,0) != PLAY_TREE_ITER_ENTRY) {
eof = PT_NEXT_ENTRY;
return eof;
}
- play_tree_remove(entry,1,1);
+ entry->remove(1,1);
eof = PT_NEXT_SRC;
return eof;
}
@@ -1681,7 +1681,7 @@
MPXPSystem& MPXPSys=*mpxp_context().engine().MPXPSys;
MPXPSys.init_keyboard_fifo();
- MPXPSys.playtree = play_tree_new();
+ MPXPSys.playtree = new(zeromem) PlayTree;
m_config_t& m_config=m_config_new(MPXPSys.playtree,MPXPSys.libinput());
mpxp_context().mconfig = &m_config;
@@ -1708,10 +1708,10 @@
#if defined( ARCH_X86 ) || defined(ARCH_X86_64)
get_mmx_optimizations();
#endif
- if(mp_conf.shuffle_playback) MPXPSys.playtree->flags|=PLAY_TREE_RND;
- else MPXPSys.playtree->flags&=~PLAY_TREE_RND;
+ if(mp_conf.shuffle_playback) MPXPSys.playtree->set_flags(MPXPSys.playtree->get_flags()|PLAY_TREE_RND);
+ else MPXPSys.playtree->set_flags(MPXPSys.playtree->get_flags()&~PLAY_TREE_RND);
- MPXPSys.playtree = play_tree_cleanup(MPXPSys.playtree);
+// MPXPSys.playtree = play_tree_cleanup(MPXPSys.playtree);
if(MPXPSys.playtree) {
MPXPSys.playtree_iter = new _PlayTree_Iter(MPXPSys.playtree,m_config);
if(MPXPSys.playtree_iter) {
Modified: mplayerxp/postproc/libmenu/menu_pt.cpp
===================================================================
--- mplayerxp/postproc/libmenu/menu_pt.cpp 2012-12-27 14:05:33 UTC (rev 607)
+++ mplayerxp/postproc/libmenu/menu_pt.cpp 2012-12-27 16:37:25 UTC (rev 608)
@@ -27,7 +27,7 @@
struct list_entry_s {
struct list_entry p;
- play_tree_t* pt;
+ PlayTree* pt;
};
@@ -57,24 +57,24 @@
case MENU_CMD_OK: {
int d = 1;
char str[15];
- play_tree_t* i;
+ PlayTree* i;
mp_cmd_t* c;
_PlayTree_Iter* _playtree_iter =mpxp_get_playtree_iter();
if(_playtree_iter->get_tree() == mpriv->p.current->pt)
break;
- if(_playtree_iter->get_tree()->parent && mpriv->p.current->pt == _playtree_iter->get_tree()->parent)
+ if(_playtree_iter->get_tree()->get_parent() && mpriv->p.current->pt == _playtree_iter->get_tree()->get_parent())
snprintf(str,15,"pt_up_step 1");
else {
- for(i = _playtree_iter->get_tree()->next; i != NULL ; i = i->next) {
+ for(i = _playtree_iter->get_tree()->get_next(); i != NULL ; i = i->get_next()) {
if(i == mpriv->p.current->pt)
break;
d++;
}
if(i == NULL) {
d = -1;
- for(i = _playtree_iter->get_tree()->prev; i != NULL ; i = i->prev) {
+ for(i = _playtree_iter->get_tree()->get_prev(); i != NULL ; i = i->get_prev()) {
if(i == mpriv->p.current->pt)
break;
d--;
@@ -106,7 +106,7 @@
}
static int op(menu_t* menu,const char* args) {
- play_tree_t* i;
+ PlayTree* i;
list_entry_t* e;
_PlayTree_Iter* _playtree_iter = mpxp_get_playtree_iter();
@@ -121,19 +121,19 @@
mpriv->p.title = mpriv->title;
- if(_playtree_iter->get_tree()->parent != _playtree_iter->get_root()) {
+ if(_playtree_iter->get_tree()->get_parent() != _playtree_iter->get_root()) {
e = new(zeromem) list_entry_t;
e->p.txt = "..";
- e->pt = _playtree_iter->get_tree()->parent;
+ e->pt = _playtree_iter->get_tree()->get_parent();
menu_list_add_entry(menu,e);
}
- for(i = _playtree_iter->get_tree() ; i->prev != NULL ; i = i->prev)
+ for(i = _playtree_iter->get_tree() ; i->get_prev() != NULL ; i = i->get_prev())
/* NOP */;
- for( ; i != NULL ; i = i->next ) {
+ for( ; i != NULL ; i = i->get_next() ) {
e = new(zeromem) list_entry_t;
- if(!i->files.empty())
- e->p.txt = mp_basename(i->files[0]);
+ if(!i->get_files().empty())
+ e->p.txt = mp_basename(i->get_file(0));
else
e->p.txt = "Group ...";
e->pt = i;
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
