kplayer/kplayer/kplayernode.cpp

/***************************************************************************
                          kplayernode.cpp
                          ---------------
    begin                : Wed Feb 16 2005
    copyright            : (C) 2005-2007 by kiriuja
    email                : http://kplayer.sourceforge.net/email.html
 ***************************************************************************/

/***************************************************************************
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation, either version 3 of the License, or     *
 *   (at your option) any later version.                                   *
 ***************************************************************************/

#ifdef HAVE_SYS_SYSMACROS_H
#include <sys/sysmacros.h>
#endif
#include <sys/types.h>

#include <klargefile.h>
#include <tdelocale.h>
#include <kmdcodec.h>
#include <tdeio/netaccess.h>
#include <tqregexp.h>

#ifdef DEBUG
#define DEBUG_KPLAYER_NODE
#endif

#include "kplayernode.h"
#include "kplayernode.moc"
#include "kplayerprocess.h"
#include "kplayersettings.h"
#include "kplayersource.h"

KPlayerRootNode* KPlayerNode::m_root = 0;
TQString KPlayerNode::m_sort_key ("Name");
bool KPlayerNode::m_sort_by_name = true;
bool KPlayerNode::m_sort_ascending = true;

#ifndef UDS_LOCAL_PATH
#define UDS_LOCAL_PATH (72 | TDEIO::UDS_STRING)
#endif

static TQString itemLocalPath (const KFileItem& item)
{
  TDEIO::UDSEntry::ConstIterator iterator = item.entry().begin();
  const TDEIO::UDSEntry::ConstIterator end = item.entry().end();
  while ( iterator != end )
  {
    const TDEIO::UDSAtom& atom = *iterator;
    if ( atom.m_uds == UDS_LOCAL_PATH )
      return atom.m_str;
    ++ iterator;
  }
  return TQString::null;
}

KPlayerNode::~KPlayerNode()
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "Destroying node\n";
  kdDebugTime() << " ID     " << id() << "\n";
#endif
  KPlayerMedia::release (media());
}

void KPlayerNode::setup (KPlayerContainerNode* parent, const TQString& id, KPlayerContainerNode* origin)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "Initializing node\n";
  kdDebugTime() << " ID     " << id << "\n";
  if ( parent )
    kdDebugTime() << " Parent " << parent -> url().url() << "\n";
#endif
  m_references = 0;
  setParent (parent);
  m_id = id;
  if ( parent )
    parent -> reference();
  setupMedia();
  setupChildren (origin);
}

void KPlayerNode::setupMedia (void)
{
  m_media = KPlayerMedia::genericProperties (metaurl());
  connect (media(), SIGNAL (updated()), SLOT (updated()));
}

void KPlayerNode::setupChildren (KPlayerContainerNode*)
{
}

bool KPlayerNode::ready (void) const
{
  return true;
}

TQString KPlayerNode::suggestId (void) const
{
  return metaurl().url();
}

KURL KPlayerNode::url (void) const
{
  return parent() -> url (id());
}

KURL KPlayerNode::url (const TQString& id) const
{
  KURL idurl (url());
  idurl.addPath (id);
  return idurl;
}

KURL KPlayerNode::metaurl (void) const
{
  return url();
}

KURL KPlayerNode::metaurl (const TQString& id) const
{
  KURL idurl (media() -> url());
  idurl.addPath (id);
  return idurl;
}

TQString KPlayerNode::icon (void) const
{
  return media() -> icon();
}

KPlayerContainerNode* KPlayerNode::topLevelNode (void) const
{
  if ( ! parent() )
    return 0;
  if ( ! parent() -> parent() )
    return (KPlayerContainerNode*) this;
  KPlayerContainerNode* node = parent();
  while ( node -> parent() -> parent() )
    node = node -> parent();
  return node;
}

bool KPlayerNode::isContainer (void) const
{
  return false;
}

bool KPlayerNode::hasProperties (void) const
{
  return false;
}

bool KPlayerNode::canRename (void) const
{
  return true;
}

int KPlayerNode::compare (KPlayerNode* node) const
{
  if ( parent() -> customOrder() )
    return parent() -> compareByPosition (this, node);
  if ( isContainer() != node -> isContainer() )
    return isContainer() == parent() -> groupsFirst() ? -1 : 1;
  int result = media() -> compare (node -> media(), sortKey());
  if ( result == 0 && ! sortByName() )
    result = compareStrings (name(), node -> name());
  return sortAscending() ? result : - result;
}

int KPlayerNode::compareByName (KPlayerNode* node) const
{
  return parent() -> customOrder() ? parent() -> compareByPosition (this, node)
    : compareStrings (name(), node -> name());
}

void KPlayerNode::countAttributes (KPlayerPropertyCounts& counts) const
{
  media() -> count (counts);
}

void KPlayerNode::updated (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerNode::updated\n";
  kdDebugTime() << " URL    " << url().url() << "\n";
#endif
  parent() -> updateAttributes (this);
}

void KPlayerNode::release (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "Releasing node\n";
  kdDebugTime() << " URL    " << url() << "\n";
  kdDebugTime() << " References " << (m_references - 1) << "\n";
#endif
  if ( -- m_references )
    return;
  if ( parent() )
  {
    parent() -> release (this);
    parent() -> release();
  }
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "Deleting node\n";
  kdDebugTime() << " ID     " << id() << "\n";
#endif
  delete this;
}

void KPlayerNode::detach (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "Detaching node\n";
  kdDebugTime() << " ID     " << url() << "\n";
#endif
  if ( parent() )
    parent() -> release (this);
}

KPlayerMediaNode* KPlayerNode::previousMediaNode (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerNode::previousMediaNode\n";
  kdDebugTime() << " URL    " << url().url() << "\n";
#endif
  for ( KPlayerNode* node = this; node -> parent(); node = node -> parent() )
  {
    KPlayerNodeList nodes (node -> parent() -> nodes());
    nodes.findRef (node);
    if ( nodes.prev() )
      return nodes.current() -> lastMediaNode();
  }
  return 0;
}

void KPlayerNode::initialize (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "Initializing node hierarchy\n";
#endif
  m_root = new KPlayerRootNode;
  root() -> setup (0, "kplayer:/");
  root() -> populate();
}

void KPlayerNode::terminate (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "Terminating node hierarchy\n";
#endif
  root() -> temporaryNode() -> release();
  root() -> vacate();
}

void KPlayerNode::setSorting (const TQString& key, bool ascending)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerNode::setSorting\n";
  kdDebugTime() << " Key    " << key << "\n";
  kdDebugTime() << " Ascending " << ascending << "\n";
#endif
  m_sort_key = key;
  m_sort_by_name = key == "Name";
  m_sort_ascending = ascending;
}

KPlayerMediaNode::~KPlayerMediaNode()
{
}

void KPlayerMediaNode::setupMedia (void)
{
  setupUrl();
  m_media = KPlayerMedia::trackProperties (metaurl());
  connect (media(), SIGNAL (updated()), SLOT (updated()));
}

void KPlayerMediaNode::setupUrl (void)
{
}

bool KPlayerMediaNode::hasProperties (void) const
{
  return true;
}

KPlayerMediaNode* KPlayerMediaNode::lastMediaNode (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerMediaNode::lastMediaNode\n";
  kdDebugTime() << " URL    " << url().url() << "\n";
#endif
  return this;
}

KPlayerFileNode::~KPlayerFileNode()
{
}

bool KPlayerFileNode::canRename (void) const
{
  return false;
}

KPlayerTrackNode::~KPlayerTrackNode()
{
}

KURL KPlayerTrackNode::metaurl (void) const
{
  KURL url (parent() -> media() -> url());
  url.addPath (id());
  return url;
}

KPlayerChannelNode::~KPlayerChannelNode()
{
}

KPlayerItemNode::~KPlayerItemNode()
{
}

void KPlayerItemNode::setupUrl (void)
{
  m_url = id();
  m_url.setRef (TQString::null);
}

KURL KPlayerItemNode::metaurl (void) const
{
  return m_url;
}

#if 0
KPlayerSearchItemNode::~KPlayerSearchItemNode()
{
}
#endif

KPlayerContainerNode::KPlayerContainerNode (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "Creating container node\n";
#endif
  m_populate_nodes = m_populate_groups = 0;
  setParent (0);
  setOrigin (0);
}

KPlayerContainerNode::~KPlayerContainerNode()
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "Destroying container node\n";
  kdDebugTime() << " ID     " << id() << "\n";
#endif
  if ( origin() )
    origin() -> release();
  delete source();
}

void KPlayerContainerNode::setupChildren (KPlayerContainerNode* origin)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "Creating node children\n";
  kdDebugTime() << " ID     " << id() << "\n";
#endif
  if ( ! origin && parent() && parent() -> origin() )
    origin = parent() -> origin() -> getNodeById (id());
  if ( ! origin )
  {
    const KURL& originurl (media() -> origin());
    if ( ! originurl.isEmpty() && originurl != url() )
      origin = root() -> getNodeByUrl (originurl);
  }
  setOrigin (origin);
  setupOrigin();
  if ( m_origin )
  {
    m_origin -> reference();
#ifdef DEBUG_KPLAYER_NODE
    kdDebugTime() << " Origin " << m_origin -> url().url() << "\n";
#endif
  }
  setupSource();
  source() -> connectOrigin();
}

void KPlayerContainerNode::setupOrigin (void)
{
}

void KPlayerContainerNode::setupSource (void)
{
  m_source = new KPlayerListSource (this);
}

bool KPlayerContainerNode::ready (void) const
{
  return ! origin() || origin() -> ready();
}

TQString KPlayerContainerNode::icon (void) const
{
  return origin() ? origin() -> icon() : "folder";
}

TQString KPlayerContainerNode::openIcon (void) const
{
  return origin() ? origin() -> icon() : "folder_open";
}

TQString KPlayerContainerNode::suggestId (void) const
{
  return id();
}

bool KPlayerContainerNode::isContainer (void) const
{
  return true;
}

bool KPlayerContainerNode::isGroup (void) const
{
  return false;
}

bool KPlayerContainerNode::isDirectory (void) const
{
  return false;
}

bool KPlayerContainerNode::isCollection (void) const
{
  return false;
}

bool KPlayerContainerNode::isPlaylist (void) const
{
  return false;
}

bool KPlayerContainerNode::isRecent (void) const
{
  return false;
}

bool KPlayerContainerNode::isNowPlaying (void) const
{
  return false;
}

bool KPlayerContainerNode::isDevices (void) const
{
  return false;
}

bool KPlayerContainerNode::canQueue (void) const
{
  return ! isNowPlaying();
}

#if 0
bool KPlayerContainerNode::canGroup (void) const
{
  return isCollection();
}
#endif

bool KPlayerContainerNode::canSaveAsPlaylist (void) const
{
  return true;
}

bool KPlayerContainerNode::groupsFirst (void) const
{
  return ! isPlaylist();
}

bool KPlayerContainerNode::canCopy (const KPlayerNodeList& nodes) const
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::canCopy\n";
  kdDebugTime() << " Target " << url().url() << "\n";
#endif
  if ( ! canAddLeaves() )
    return false;
  KPlayerNodeListIterator iterator (nodes);
  while ( KPlayerNode* node = iterator.current() )
  {
    if ( node -> isContainer() )
    {
      const KPlayerContainerNode* parent = this;
      while ( parent )
      {
        if ( node == parent )
          return false;
        parent = parent -> parent();
      }
    }
    ++ iterator;
  }
  return true;
}

bool KPlayerContainerNode::canLink (const KPlayerNodeList& nodes) const
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::canLink\n";
  kdDebugTime() << " Target " << url().url() << "\n";
#endif
  KPlayerNodeListIterator iterator (nodes);
  while ( KPlayerNode* node = iterator.current() )
  {
    if ( node -> isContainer() && canLink ((KPlayerContainerNode*) node) )
      return true;
    ++ iterator;
  }
  return false;
}

bool KPlayerContainerNode::canLink (KPlayerContainerNode* node) const
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::canLink\n";
  kdDebugTime() << " Node   " << node -> url() << "\n";
#endif
  return false;
}

bool KPlayerContainerNode::preferMove (KPlayerNode* node) const
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::preferMove\n";
  kdDebugTime() << " Target " << url().url() << "\n";
  kdDebugTime() << " Node   " << node -> url().url() << "\n";
#endif
  return topLevelNode() == node -> topLevelNode();
}

void KPlayerContainerNode::release (KPlayerNode* node)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "Releasing child node\n";
  kdDebugTime() << " URL    " << node -> url() << "\n";
#endif
  if ( remove (node) )
  {
    if ( populated() )
      node -> release();
    if ( groupsPopulated() && node -> isContainer() )
      node -> release();
  }
}

void KPlayerContainerNode::addBranch (const TQString& name, KPlayerNode* after)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::addBranch\n";
  kdDebugTime() << " Name   " << name << "\n";
  if ( after )
    kdDebugTime() << " After  " << after -> url().url() << "\n";
#endif
  KPlayerContainerNode* node = new KPlayerExternalNode;
  node -> setup (0, name);
  node -> reference();
  KPlayerNodeList list;
  list.append (node);
  add (list, false, after);
  node -> release();
}

void KPlayerContainerNode::appendBranch (const TQString& name)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::appendBranch\n";
  kdDebugTime() << " Name   " << name << "\n";
#endif
  populate();
  addBranch (name, lastNode());
  vacate();
}

void KPlayerContainerNode::add (const KURL::List& urls, bool link, KPlayerNode* after)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::add url list\n";
#endif
  if ( urls.isEmpty() )
    return;
  KPlayerNodeList list (KPlayerNodeList::fromUrlList (urls));
  if ( ! list.isEmpty() )
  {
    add (list, link, after);
    list.releaseAll();
  }
}

void KPlayerContainerNode::append (const KURL::List& urls)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::append url list\n";
#endif
  populate();
  add (urls, true, lastNode());
  vacate();
}

void KPlayerContainerNode::add (const KPlayerNodeList& nodes, bool link, KPlayerNode* after)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << (link ? "Linking" : "Copying") << " nodes\n";
  if ( after )
    kdDebugTime() << " After  " << after -> url().url() << "\n";
#endif
  KPlayerItemProperties::resetMetaInfoTimer();
  source() -> add (nodes, link, after);
}

void KPlayerContainerNode::append (const KPlayerNodeList& nodes)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::append\n";
#endif
  populate();
  add (nodes, true, lastNode());
  vacate();
}

void KPlayerContainerNode::move (const KPlayerNodeList& nodes, KPlayerNode* after)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "Moving nodes\n";
  if ( after )
    kdDebugTime() << " After  " << after -> url().url() << "\n";
#endif
  populate();
  KPlayerContainerNode* parent = nodes.getFirst() -> parent();
  KPlayerNodeList list;
  KPlayerNodeListIterator iterator (nodes);
  while ( KPlayerNode* node = iterator.current() )
  {
    if ( parent != node -> parent() )
    {
      if ( parent == this )
        after = moved (list, after);
      else
      {
        after = source() -> add (list, false, after);
        parent -> remove (list);
      }
      list.clear();
      parent = node -> parent();
    }
    list.append (node);
    ++ iterator;
  }
  if ( parent == this )
    moved (list, after);
  else
  {
    source() -> add (list, false, after);
    parent -> remove (list);
  }
  vacate();
}

void KPlayerContainerNode::remove (const KPlayerNodeList& nodes)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "Removing nodes\n";
#endif
  source() -> remove (nodes);
}

KPlayerNode* KPlayerContainerNode::createLeaf (const TQString& id)
{
  KPlayerNode* node = new KPlayerItemNode;
  node -> setup (this, id);
  return node;
}

KPlayerContainerNode* KPlayerContainerNode::createBranch (const TQString&, KPlayerContainerNode*)
{
  return 0;
}

void KPlayerContainerNode::insert (KPlayerNode* node, KPlayerNode* after)
{
  if ( after == this )
    m_nodes.prepend (node);
  else if ( after && m_nodes.findRef (after) >= 0 )
    m_nodes.insert (nodes().at() + 1, node);
  else
  {
    m_nodes.append (node);
#ifdef DEBUG_KPLAYER_NODE
    if ( after )
      kdDebugTime() << " After node not found\n";
#endif
  }
  m_node_map.insert (node -> id(), node);
}

void KPlayerContainerNode::append (KPlayerNode* node)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "Appending node\n";
  kdDebugTime() << " ID     " << node -> id() << "\n";
#endif
  m_nodes.append (node);
  m_node_map.insert (node -> id(), node);
}

KPlayerNode* KPlayerContainerNode::insertLeaf (const TQString& id, KPlayerNode* after)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "Inserting leaf node\n";
  kdDebugTime() << " ID     " << id << "\n";
  if ( after )
    kdDebugTime() << " After  " << after -> url().url() << "\n";
#endif
  KPlayerNode* node = createLeaf (id);
  if ( node )
  {
    insert (node, after);
    if ( populated() )
      node -> reference();
  }
  return node;
}

KPlayerContainerNode* KPlayerContainerNode::insertBranch (const TQString& id,
  KPlayerNode* after, KPlayerContainerNode* origin)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "Inserting branch node\n";
  kdDebugTime() << " ID     " << id << "\n";
  if ( origin )
    kdDebugTime() << " Origin " << origin -> url().url() << "\n";
  if ( after )
    kdDebugTime() << " After  " << after -> url().url() << "\n";
#endif
  KPlayerContainerNode* node = createBranch (id, origin);
  if ( node )
  {
    insert (node, after);
    if ( populated() )
      node -> reference();
    if ( groupsPopulated() )
      node -> reference();
  }
  return node;
}

void KPlayerContainerNode::populate (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::populate\n";
  kdDebugTime() << " Count  " << m_populate_nodes << "\n";
  kdDebugTime() << " URL    " << url().url() << "\n";
#endif
  reference();
  if ( ! populated() )
    doPopulate();
  m_populate_nodes ++;
}

void KPlayerContainerNode::doPopulate (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "Populating node\n";
  kdDebugTime() << " URL    " << url().url() << "\n";
#endif
  bool apply_custom_order = media() -> customOrder() && (origin() || ! nodes().isEmpty());
  if ( origin() )
    origin() -> populate();
  KPlayerNodeList previous (nodes());
  KPlayerNodeMap map (m_node_map);
  m_nodes.clear();
  m_node_map.clear();
  bool group;
  TQString id;
  source() -> start (false);
  while ( source() -> next (group, id) )
  {
    KPlayerNode* node = 0;
    if ( group )
    {
      KPlayerNodeMap::ConstIterator iterator = map.find (id);
      if ( iterator != map.end() )
      {
        node = *iterator;
        previous.removeRef (node);
        iterator = map.end();
        map.remove (id);
      }
    }
    else if ( ! acceptsDuplicates() )
      id = id.section ('#', 0, 0);
    if ( nodeById (id) )
      continue;
    if ( node )
      append (node);
    else
      node = group ? insertBranch (id) : insertLeaf (id);
    if ( node )
    {
      node -> reference();
      node -> countAttributes (m_attribute_counts);
    }
  }
  if ( ! previous.isEmpty() )
  {
#ifdef DEBUG_KPLAYER_NODE
    kdDebugTime() << " Remaining " << previous.count() << "\n";
#endif
    KPlayerNodeListIterator iterator (previous);
    while ( KPlayerNode* node = iterator.current() )
    {
      append (node);
      ++ iterator;
    }
  }
  if ( apply_custom_order )
    applyCustomOrder();
}

void KPlayerContainerNode::populateGroups (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::populateGroups\n";
  kdDebugTime() << " Count  " << m_populate_groups << "\n";
  kdDebugTime() << " URL    " << url().url() << "\n";
#endif
  reference();
  if ( ! groupsPopulated() )
    if ( populated() )
    {
#ifdef DEBUG_KPLAYER_NODE
      kdDebugTime() << " Adding references\n";
#endif
      if ( origin() )
        origin() -> populateGroups();
      KPlayerNodeListIterator iterator (nodes());
      while ( KPlayerNode* node = iterator.current() )
      {
        if ( node -> isContainer() )
          node -> reference();
        ++ iterator;
      }
    }
    else
      doPopulateGroups();
  m_populate_groups ++;
}

void KPlayerContainerNode::doPopulateGroups (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "Populating groups\n";
  kdDebugTime() << " URL    " << url().url() << "\n";
#endif
  bool apply_custom_order = media() -> customOrder() && (origin() || ! nodes().isEmpty());
  if ( origin() )
    origin() -> populateGroups();
  KPlayerNodeList previous (nodes());
  KPlayerNodeMap map (m_node_map);
  m_nodes.clear();
  m_node_map.clear();
  bool group;
  TQString id;
  source() -> start (true);
  while ( source() -> next (group, id) )
  {
    KPlayerNodeMap::ConstIterator iterator = map.find (id);
    KPlayerNode* node = iterator == map.end() ? 0 : *iterator;
    if ( node )
    {
      previous.removeRef (node);
      map.remove (id);
      append (node);
    }
    else
      node = insertBranch (id);
    if ( node )
      node -> reference();
  }
  if ( ! previous.isEmpty() )
  {
#ifdef DEBUG_KPLAYER_NODE
    kdDebugTime() << " Remaining " << previous.count() << "\n";
#endif
    KPlayerNodeListIterator iterator (previous);
    while ( KPlayerNode* node = iterator.current() )
    {
      append (node);
      ++ iterator;
    }
  }
  if ( apply_custom_order )
    applyCustomOrder();
}

void KPlayerContainerNode::populateAll (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::populateAll\n";
  kdDebugTime() << " URL    " << url().url() << "\n";
#endif
  populate();
  for ( KPlayerNode* node = m_nodes.first(); node; node = m_nodes.next() )
    if ( node -> isContainer() )
      ((KPlayerContainerNode*) node) -> populateAll();
}

void KPlayerContainerNode::vacate (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::vacate\n";
  kdDebugTime() << " Count  " << m_populate_nodes << "\n";
  kdDebugTime() << " ID     " << url() << "\n";
#endif
  if ( m_populate_nodes == 1 )
  {
#ifdef DEBUG_KPLAYER_NODE
    kdDebugTime() << "Vacating node\n";
    kdDebugTime() << " ID     " << url() << "\n";
#endif
    KPlayerNodeList nodes (m_nodes);
    for ( KPlayerNode* node = nodes.first(); node; node = nodes.next() )
      node -> release();
    if ( origin() )
      origin() -> vacate();
    m_attribute_counts.clear();
  }
  m_populate_nodes --;
  release();
}

void KPlayerContainerNode::vacateGroups (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::vacateGroups\n";
  kdDebugTime() << " Count  " << m_populate_groups << "\n";
  kdDebugTime() << " ID     " << url() << "\n";
#endif
  if ( m_populate_groups == 1 )
  {
#ifdef DEBUG_KPLAYER_NODE
    kdDebugTime() << "Vacating groups\n";
    kdDebugTime() << " URL    " << url() << "\n";
#endif
    KPlayerNodeList nodes (m_nodes);
    for ( KPlayerNode* node = nodes.first(); node; node = nodes.next() )
      if ( node -> isContainer() )
        node -> release();
    if ( origin() )
      origin() -> vacateGroups();
  }
  m_populate_groups --;
  release();
}

void KPlayerContainerNode::vacateAll (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::vacateAll\n";
  kdDebugTime() << " URL    " << url().url() << "\n";
#endif
  for ( KPlayerNode* node = m_nodes.first(); node; node = m_nodes.next() )
    if ( node -> isContainer() )
      ((KPlayerContainerNode*) node) -> vacateAll();
  vacate();
}

void KPlayerContainerNode::refreshNodes (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::refreshNodes\n";
  kdDebugTime() << " URL    " << url().url() << "\n";
#endif
  removed (nodes());
  if ( groupsPopulated() )
  {
    int count = m_populate_groups;
    m_populate_groups = 0;
    doPopulateGroups();
    m_populate_groups = count;
  }
  if ( populated() )
  {
    int count = m_populate_nodes;
    m_populate_nodes = 0;
    doPopulate();
    m_populate_nodes = count;
  }
  if ( ! attributeCounts().isEmpty() )
    emitAttributesUpdated (attributeCounts(), KPlayerPropertyCounts());
  emitAdded (nodes());
}

KPlayerNode* KPlayerContainerNode::nodeById (const TQString& id) const
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::nodeById '" << id << "'\n";
  kdDebugTime() << " URL    " << url().url() << "\n";
#endif
  KPlayerNodeMap::ConstIterator iterator = m_node_map.find (id);
  return iterator == m_node_map.end() ? 0 : *iterator;
}

KPlayerContainerNode* KPlayerContainerNode::getNodeById (const TQString& id)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::getNodeById\n";
  kdDebugTime() << " ID     " << id << "\n";
  kdDebugTime() << " URL    " << url().url() << "\n";
#endif
  KPlayerNode* node = nodeById (id);
  if ( ! node || node -> isContainer() )
  {
    KPlayerContainerNode* container = (KPlayerContainerNode*) node;
    if ( ! container && source() -> verify (id) )
      container = insertBranch (id);
    if ( container )
      return container;
  }
  reference();
  release();
  return 0;
}

KPlayerContainerNode* KPlayerContainerNode::getNodeByPath (const TQString& path)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::getNodeByPath\n";
  kdDebugTime() << " Path   " << path << "\n";
#endif
  KPlayerContainerNode* node = getNodeById (path.section ('/', 0, 0, TQString::SectionSkipEmpty));
  if ( node )
  {
    TQString subpath (path.section ('/', 1, 0xffffffff, TQString::SectionSkipEmpty));
    if ( ! subpath.isEmpty() )
      node = node -> getNodeByPath (subpath);
  }
  return node;
}

KPlayerNode* KPlayerContainerNode::nextNode (KPlayerNode* node)
{
  return m_nodes.findRef (node) >= 0 ? m_nodes.next() : 0;
}

KPlayerMediaNode* KPlayerContainerNode::lastMediaNode (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::lastMediaNode\n";
  kdDebugTime() << " URL    " << url().url() << "\n";
#endif
  KPlayerNodeListIterator iterator (m_nodes);
  iterator.toLast();
  while ( KPlayerNode* node = iterator.current() )
  {
    KPlayerMediaNode* medianode = node -> lastMediaNode();
    if ( medianode )
    {
#ifdef DEBUG_KPLAYER_NODE
      kdDebugTime() << " Found  " << medianode -> url().url() << "\n";
#endif
      return medianode;
    }
    -- iterator;
  }
  return previousMediaNode();
}

void KPlayerContainerNode::customOrderByName (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::customOrderByName\n";
#endif
  if ( ! customOrder() && allowsCustomOrder() )
  {
    TQString key (sortKey());
    bool ascending = sortAscending();
    setSorting ("Name", true);
    m_nodes.sort();
    setSorting (key, ascending);
    setCustomOrder (true);
  }
}

bool KPlayerContainerNode::customOrder (void) const
{
  return ! origin() || media() -> hasCustomOrder() ? ! parent() || media() -> customOrder() : origin() -> customOrder();
}

void KPlayerContainerNode::setCustomOrder (bool custom)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::setCustomOrder\n";
  kdDebugTime() << " Custom " << custom << "\n";
#endif
  if ( parent() && allowsCustomOrder() )
  {
    if ( custom || origin() && origin() -> customOrder() )
      media() -> setCustomOrder (custom);
    else
      media() -> resetCustomOrder();
    media() -> commit();
  }
}

bool KPlayerContainerNode::allowsCustomOrder (void) const
{
  return true;
}

bool KPlayerContainerNode::acceptsDuplicates (void) const
{
  return false;
}

int KPlayerContainerNode::compareByPosition (const KPlayerNode* node1, const KPlayerNode* node2)
{
  int i1 = m_nodes.findRef (node1);
  int i2 = m_nodes.findRef (node2);
  return i1 == i2 ? 0 : i1 < i2 ? -1 : 1;
}

void KPlayerContainerNode::addedLeaves (const TQStringList& list)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::addedLeaves\n";
  kdDebugTime() << " URL    " << url().url() << "\n";
#endif
  KPlayerNodeList nodes;
  if ( ! list.isEmpty() && populated() )
  {
    KPlayerPropertyCounts counts;
    TQStringList::ConstIterator iterator (list.begin());
    while ( iterator != list.end() )
    {
      KPlayerNode* node = insertLeaf (*iterator);
      if ( node )
      {
        node -> countAttributes (counts);
        nodes.append (node);
      }
      ++ iterator;
    }
    source() -> save();
    if ( ! counts.isEmpty() )
    {
      m_attribute_counts.add (counts);
      emitAttributesUpdated (counts, KPlayerPropertyCounts());
    }
  }
  emitAdded (nodes);
}

void KPlayerContainerNode::addedBranches (const TQStringList& list)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::addedBranches\n";
  kdDebugTime() << " URL    " << url().url() << "\n";
#endif
  KPlayerNodeList nodes;
  if ( ! list.isEmpty() && (populated() || groupsPopulated()) )
  {
    KPlayerPropertyCounts counts;
    TQStringList::ConstIterator iterator (list.begin());
    while ( iterator != list.end() )
    {
      KPlayerNode* node = insertBranch (*iterator);
      if ( node )
      {
        node -> countAttributes (counts);
        nodes.append (node);
      }
      ++ iterator;
    }
    if ( populated() )
    {
      source() -> save();
      if ( ! counts.isEmpty() )
      {
        m_attribute_counts.add (counts);
        emitAttributesUpdated (counts, KPlayerPropertyCounts());
      }
    }
  }
  emitAdded (nodes);
}

void KPlayerContainerNode::added (const TQFileInfoList& list)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::added file list\n";
  kdDebugTime() << " URL    " << url().url() << "\n";
#endif
  KPlayerNodeList nodes;
  if ( ! list.isEmpty() && (populated() || groupsPopulated()) )
  {
    KPlayerPropertyCounts counts;
    for ( TQFileInfoListIterator iterator (list); iterator.current(); ++ iterator )
    {
      bool group = iterator.current() -> isDir();
      if ( group || populated() )
      {
        TQString id (iterator.current() -> fileName());
        KPlayerNode* node = group ? insertBranch (id) : insertLeaf (id);
        if ( node )
        {
          node -> countAttributes (counts);
          nodes.append (node);
        }
      }
    }
    if ( populated() )
    {
      source() -> save();
      if ( ! counts.isEmpty() )
      {
        m_attribute_counts.add (counts);
        emitAttributesUpdated (counts, KPlayerPropertyCounts());
      }
    }
  }
  emitAdded (nodes);
}

void KPlayerContainerNode::added (KPlayerContainerNode* node, bool link)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::added subnodes\n";
#endif
  node -> populate();
  if ( ! node -> nodes().isEmpty() )
    added (node -> nodes(), link);
  node -> vacate();
}

KPlayerNode* KPlayerContainerNode::added (const KPlayerNodeList& nodes, bool link, KPlayerNode* after)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::added " << (link ? "link" : "copy") << " nodes\n";
  kdDebugTime() << " URL    " << url().url() << "\n";
  if ( after )
    kdDebugTime() << " After  " << after -> url().url() << "\n";
#endif
  populate();
  if ( ! allowsCustomOrder() )
    after = 0;
  else if ( after && ! customOrder() )
  {
#ifdef DEBUG_KPLAYER_NODE
    kdDebugTime() << " Key    '" << sortKey() << "'\n";
#endif
    m_nodes.sort();
    setCustomOrder (true);
  }
  KPlayerNodeList list;
  KPlayerPropertyCounts counts;
  KPlayerNode* saveAfter = after;
  KPlayerNodeListIterator iterator (nodes);
  while ( KPlayerNode* node = iterator.current() )
  {
    TQString id (node -> suggestId());
    KPlayerNode* subnode = nodeById (id);
    if ( subnode && acceptsDuplicates() )
      if ( node -> isContainer() )
      {
        TQString base (id);
        for ( int i = 0; subnode; i ++ )
        {
          id = base + TQString::number (i);
          subnode = nodeById (id);
        }
      }
      else
      {
        KURL url (id);
        for ( int i = 0; subnode; i ++ )
        {
          url.setRef (TQString::number (i));
          id = url.url();
          subnode = nodeById (id);
        }
      }
    if ( subnode )
    {
      if ( after || customOrder() )
      {
        m_nodes.removeRef (subnode);
        insert (subnode, after);
      }
      if ( subnode -> isContainer() && node -> isContainer() )
          ((KPlayerContainerNode*) subnode) -> added ((KPlayerContainerNode*) node, link);
    }
    else
    {
      if ( node -> isContainer() )
      {
        KPlayerContainerNode* container = (KPlayerContainerNode*) node;
        KPlayerContainerNode* origin = link ? container : container -> origin();
        while ( origin && ! canLink (origin) )
          origin = origin -> origin();
        KPlayerContainerNode* branch = insertBranch (id, after, origin);
        subnode = branch;
        if ( branch )
        {
          subnode -> media() -> setName (node -> name());
          if ( origin )
            branch -> save();
          else
            branch -> added (container, link);
        }
      }
      else
        subnode = insertLeaf (id, after);
      if ( subnode )
      {
        subnode -> countAttributes (counts);
        list.append (subnode);
      }
    }
    if ( after )
      after = subnode;
    ++ iterator;
  }
  if ( origin() && customOrder() && ! media() -> customOrder() )
  {
    m_nodes.clear();
    KPlayerNodeListIterator originit (origin() -> nodes());
    while ( KPlayerNode* originnode = originit.current() )
    {
      KPlayerNode* node = nodeById (originnode -> id());
      if ( node )
        m_nodes.append (node);
#ifdef DEBUG_KPLAYER_NODE
      else
        kdDebugTime() << " Missing node " << originnode -> id() << "\n";
#endif
      ++ originit;
    }
  }
  if ( ! counts.isEmpty() )
  {
    m_attribute_counts.add (counts);
    emitAttributesUpdated (counts, KPlayerPropertyCounts());
  }
  emitAdded (list, saveAfter);
  source() -> save();
  vacate();
  return after && m_nodes.findRef (after) >= 0 ? after : 0;
}

KPlayerNode* KPlayerContainerNode::moved (const KPlayerNodeList& nodes, KPlayerNode* after)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::moved\n";
  if ( after )
    kdDebugTime() << " After  " << after -> url().url() << "\n";
#endif
  populate();
  if ( ! allowsCustomOrder() )
    after = 0;
  else if ( after )
  {
#ifdef DEBUG_KPLAYER_NODE
    kdDebugTime() << " Key    '" << sortKey() << "'\n";
#endif
    m_nodes.sort();
    setCustomOrder (true);
  }
  KPlayerNode* saveAfter = after;
  KPlayerNodeListIterator iterator (nodes);
  while ( KPlayerNode* node = iterator.current() )
  {
    if ( after || customOrder() )
    {
      m_nodes.removeRef (node);
      insert (node, after);
    }
    if ( after )
      after = node;
    ++ iterator;
  }
  source() -> save();
  KPlayerNodeList list;
  emitAdded (list, saveAfter);
  vacate();
  return after && m_nodes.findRef (after) >= 0 ? after : 0;
}

KPlayerNode* KPlayerContainerNode::lastNode (void)
{
  if ( nodes().isEmpty() )
    return this;
  if ( ! customOrder() )
  {
#ifdef DEBUG_KPLAYER_NODE
    kdDebugTime() << " Sorting by " << sortKey() << "\n";
#endif
    m_nodes.sort();
    setCustomOrder (true);
  }
  return nodes().getLast();
}

bool KPlayerContainerNode::remove (KPlayerNode* node)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::remove\n";
  kdDebugTime() << " URL    " << node -> url() << "\n";
#endif
  bool found = m_nodes.removeRef (node);
  if ( found )
    m_node_map.remove (node -> id());
  return found;
}

void KPlayerContainerNode::removed (const KPlayerNodeList& nodes, const KPlayerPropertyCounts& counts)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::removed nodes and counts\n";
#endif
  emitRemoved (nodes);
  if ( ! counts.isEmpty() )
  {
    m_attribute_counts.subtract (counts);
    emitAttributesUpdated (KPlayerPropertyCounts(), counts);
  }
  nodes.releaseAll();
}

void KPlayerContainerNode::removed (const TQStringList& ids)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::removed ID list\n";
  kdDebugTime() << " URL    " << url().url() << "\n";
#endif
  KPlayerNodeList nodes;
  KPlayerPropertyCounts counts;
  if ( ! ids.isEmpty() )
  {
    populate();
    for ( TQStringList::ConstIterator iterator (ids.begin()); iterator != ids.end(); ++ iterator )
    {
      KPlayerNode* node = nodeById (*iterator);
      if ( node )
      {
        node -> countAttributes (counts);
        node -> reference();
        node -> detach();
        nodes.append (node);
      }
    }
    source() -> save();
    vacate();
  }
  removed (nodes, counts);
}

void KPlayerContainerNode::removed (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::removed node\n";
  kdDebugTime() << " URL    " << url().url() << "\n";
#endif
  removed (nodes());
  media() -> purge();
}

void KPlayerContainerNode::removed (const KPlayerNodeList& nodes)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::removed\n";
  kdDebugTime() << " URL    " << url().url() << "\n";
#endif
  KPlayerNodeList list (nodes);
  KPlayerPropertyCounts counts;
  if ( ! nodes.isEmpty() )
  {
    populate();
    KPlayerNodeListIterator iterator (list);
    while ( KPlayerNode* node = iterator.current() )
    {
      if ( node -> isContainer() )
        ((KPlayerContainerNode*) node) -> removed();
      node -> countAttributes (counts);
      node -> reference();
      node -> detach();
      ++ iterator;
    }
    source() -> save();
    vacate();
  }
  removed (list, counts);
}

void KPlayerContainerNode::save (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::save\n";
  kdDebugTime() << " URL    " << url() << "\n";
#endif
  if ( ! origin() || media() -> customOrder() )
  {
    populate();
    TQStringList children;
    KPlayerNodeListIterator iterator (nodes());
    while ( KPlayerNode* node = iterator.current() )
    {
#ifdef DEBUG_KPLAYER_NODE
      kdDebugTime() << " Child  " << node -> url() << "\n";
#endif
      children.append (node -> id());
      ++ iterator;
    }
    vacate();
    media() -> setChildren (children);
  }
  else
    media() -> resetChildren();
  if ( origin() && ! url().isLocalFile() )
  {
#ifdef DEBUG_KPLAYER_NODE
    kdDebugTime() << " Origin " << origin() -> url().url() << "\n";
#endif
    media() -> setOrigin (origin() -> url());
  }
  else
    media() -> resetOrigin();
  media() -> commit();
}

void KPlayerContainerNode::applyCustomOrder (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::applyCustomOrder\n";
  kdDebugTime() << " URL    " << url().url() << "\n";
#endif
  KPlayerNode* node;
  KPlayerNodeList list (m_nodes);
  m_nodes.clear();
  const TQStringList& children (media() -> children());
  TQStringList::ConstIterator iterator (children.begin());
  while ( iterator != children.end() )
  {
    TQString id (*iterator);
    for ( node = list.first(); node; node = list.next() )
      if ( node -> id() == id )
        break;
    if ( node )
    {
      list.remove();
      m_nodes.append (node);
    }
    ++ iterator;
  }
  for ( node = list.first(); node; node = list.next() )
    m_nodes.append (node);
}

void KPlayerContainerNode::detach (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "Detaching subnodes\n";
  kdDebugTime() << " URL    " << url().url() << "\n";
#endif
  KPlayerNodeList nodes (m_nodes);
  for ( KPlayerNode* node = nodes.first(); node; node = nodes.next() )
    node -> detach();
  emitDetached();
  KPlayerNode::detach();
}

void KPlayerContainerNode::detachOrigin (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerNode::detachOrigin\n";
#endif
  populate();
  releaseOrigin();
  KPlayerNodeListIterator iterator (nodes());
  while ( KPlayerNode* node = iterator.current() )
  {
    if ( node -> isContainer() )
    {
      KPlayerContainerNode* container = (KPlayerContainerNode*) node;
      if ( container -> origin() )
        container -> source() -> save();
    }
    ++ iterator;
  }
  source() -> save();
  vacate();
  if ( parent() && parent() -> origin() )
    parent() -> detachOrigin();
}

void KPlayerContainerNode::releaseOrigin (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerContainerNode::releaseOrigin\n";
#endif
  if ( populated() )
    origin() -> vacate();
  if ( groupsPopulated() )
    origin() -> vacateGroups();
  origin() -> release();
  setOrigin (0);
  source() -> deleteLater();
  setSource (new KPlayerStoreSource (this));
}

KPlayerTemporaryNode::~KPlayerTemporaryNode()
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "Destroying temporary node\n";
#endif
}

KPlayerNode* KPlayerTemporaryNode::temporaryItem (const TQString& id)
{
  KPlayerNode* node = nodeById (id);
  if ( ! node )
    node = insertLeaf (id);
  if ( node )
    node -> reference();
  return node;
}

KPlayerRootNode::KPlayerRootNode (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "Creating root node\n";
#endif
}

KPlayerRootNode::~KPlayerRootNode()
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "Destroying root node\n";
#endif
  m_root = 0;
}

void KPlayerRootNode::setupSource (void)
{
  TQString home ("file:" + TQDir::homeDirPath());
  m_default_ids << "nowplaying" << "recent" << "playlists" << "collection" << "devices" << "file:/" << home;
  KPlayerContainerNode* node = new KPlayerNowPlayingNode;
  node -> setup (this, "nowplaying");
  node -> media() -> setDefaultName (i18n("Now Playing"));
  m_defaults.insert ("nowplaying", node);
  node = new KPlayerPlaylistNode;
  node -> setup (this, "playlists");
  node -> media() -> setDefaultName (i18n("Playlists"));
  m_defaults.insert ("playlists", node);
  node = new KPlayerCollectionNode;
  node -> setup (this, "collection");
  node -> media() -> setDefaultName (i18n("Collection"));
  m_defaults.insert ("collection", node);
  node = new KPlayerDevicesNode;
  node -> setup (this, "devices");
  node -> media() -> setDefaultName (i18n("Devices"));
  m_defaults.insert ("devices", node);
  node = new KPlayerRecentsNode;
  node -> setup (this, "recent");
  node -> media() -> setDefaultName (i18n("Recent"));
  m_defaults.insert ("recent", node);
#if 0
  node = new KPlayerSearchesNode;
  node -> setup (this, "searches");
  node -> media() -> setDefaultName (i18n("Searches"));
  m_defaults.insert ("searches", node);
#endif
  node = new KPlayerExternalNode;
  node -> setup (this, "file:/");
  node -> media() -> setDefaultName (i18n("Root Directory"));
  m_defaults.insert ("file:/", node);
  m_externals.insert (node -> media() -> url().url(), node);
  node = new KPlayerExternalNode;
  node -> setup (this, home);
  node -> media() -> setDefaultName (i18n("Home Directory"));
  m_defaults.insert (home, node);
  m_externals.insert (node -> media() -> url().url(), node);
  m_temp = new KPlayerTemporaryNode;
  temporaryNode() -> setup (this, "temp");
  temporaryNode() -> reference();
  m_source = new KPlayerRootSource (this);
}

KURL KPlayerRootNode::url (void) const
{
  return id();
}

KPlayerContainerNode* KPlayerRootNode::createBranch (const TQString& id, KPlayerContainerNode*)
{
  KPlayerContainerNode* node;
  KPlayerContainerNodeMap::ConstIterator iterator = m_defaults.find (id);
  if ( iterator == m_defaults.end() )
  {
    node = getNodeByUrl (id);
    /*if ( node -> parent() -> parent() )
    {
      //origin = node;
      node -> reference();
      node -> release();
      node = new KPlayerExternalNode;
      node -> setup (this, id);
    }*/
  }
  else
    node = *iterator;
  return node;
}

KPlayerContainerNode* KPlayerRootNode::getNodeByUrl (const KURL& url)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerNode::getNodeByUrl\n";
  kdDebugTime() << " URL    " << url.url() << "\n";
  kdDebugTime() << " Path   " << url.path() << "\n";
#endif
  TQString path (url.path());
  KPlayerContainerNode* node = 0;
  if ( url.protocol() == "kplayer" )
    node = root();
  else
  {
    uint length = 0;
    TQString urls (url.url());
    KPlayerContainerNodeMap::ConstIterator iterator (m_externals.begin());
    while ( iterator != m_externals.end() )
    {
      if ( urls.startsWith (iterator.key()) && iterator.key().length() > length
        && url.path().startsWith (iterator.data() -> url().path()) )
      {
        node = iterator.data();
        length = iterator.key().length();
        path = url.path().mid (node -> url().path().length());
      }
      ++ iterator;
    }
    if ( ! node )
    {
      TQString id (url.protocol() + ":/");
      node = new KPlayerExternalNode;
      node -> setup (root(), id);
      m_externals.insert (node -> media() -> url().url(), node);
    }
  }
  return path.section ('/', 0, 0, TQString::SectionSkipEmpty).isEmpty() ? node
    : node -> getNodeByPath (path);
}

KPlayerExternalNode::~KPlayerExternalNode()
{
}

KURL KPlayerExternalNode::url (void) const
{
  return id();
}

KPlayerDirectoryNode::~KPlayerDirectoryNode()
{
}

void KPlayerDirectoryNode::setupSource (void)
{
//m_source = origin() ? (KPlayerSource*) new KPlayerOriginSource (this)
//  : (KPlayerSource*) new KPlayerDirectorySource (this);
  m_source = new KPlayerDirectorySource (this);
}

bool KPlayerDirectoryNode::isDirectory (void) const
{
  return true;
}

bool KPlayerDirectoryNode::canRename (void) const
{
  return false;
}

bool KPlayerDirectoryNode::allowsCustomOrder (void) const
{
  return false;
}

KPlayerNode* KPlayerDirectoryNode::createLeaf (const TQString& id)
{
  KPlayerNode* node = new KPlayerFileNode;
  node -> setup (this, id);
  return node;
}

KPlayerContainerNode* KPlayerDirectoryNode::createBranch (const TQString& id, KPlayerContainerNode* origin)
{
  KPlayerContainerNode* node = new KPlayerDirectoryNode;
  node -> setup (this, id, origin);
  return node;
}

KPlayerGroupNode::~KPlayerGroupNode()
{
}

void KPlayerGroupNode::setupSource (void)
{
  m_source = origin() ? (KPlayerSource*) new KPlayerOriginSource (this) : (KPlayerSource*) new KPlayerStoreSource (this);
}

TQString KPlayerGroupNode::icon (void) const
{
  return origin() ? origin() -> icon() : "folder_green";
}

TQString KPlayerGroupNode::openIcon (void) const
{
  return origin() ? origin() -> icon() : "folder_green_open";
}

bool KPlayerGroupNode::isGroup (void) const
{
  return true;
}

bool KPlayerGroupNode::canRename (void) const
{
  return parent() && parent() -> parent();
}

KPlayerCollectionNode::~KPlayerCollectionNode()
{
}

void KPlayerCollectionNode::setupOrigin (void)
{
#if 0
#ifdef DEBUG_KPLAYER_NODE
  if ( isGrouped() )
    kdDebugTime() << " Key    " << groupingKey() << "\n";
#endif
  if ( isParentGrouped() )
    setOrigin (parent());
  else if ( isGrouped() )
    setOrigin (createBranch (id(), origin()));
#endif
}

#if 0
void KPlayerCollectionNode::setupSource (void)
{
  m_source =
    isParentGrouped() ? (KPlayerSource*) new KPlayerKeySource (this) :
    isGrouped() ? (KPlayerSource*) new KPlayerGroupSource (this) :
    origin() ? (KPlayerSource*) new KPlayerOriginSource (this) : (KPlayerSource*) new KPlayerStoreSource (this);
}
#endif

bool KPlayerCollectionNode::isCollection (void) const
{
  return true;
}

bool KPlayerCollectionNode::canLink (KPlayerContainerNode* node) const
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerCollectionNode::canLink\n";
  kdDebugTime() << " Node   " << node -> url() << "\n";
#endif
  return node -> isDirectory();
}

bool KPlayerCollectionNode::allowsCustomOrder (void) const
{
  return false;
}

KPlayerContainerNode* KPlayerCollectionNode::createBranch (const TQString& id, KPlayerContainerNode* origin)
{
  KPlayerContainerNode* node = new KPlayerCollectionNode;
  node -> setup (this, id, origin);
  return node;
}

#if 0
void KPlayerCollectionNode::group (const TQString& key)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "Group nodes\n";
  if ( ! key.isNull() )
    kdDebugTime() << " Key    '" << key << "'\n";
  kdDebugTime() << " URL    " << url().url() << "\n";
#endif
  if ( groupingKey() == key || key.isNull() && parent() && isParentGrouped() )
    return;
  media() -> setGroupingKey (key);
  KPlayerNodeList nodes (m_nodes);
  for ( KPlayerNode* node = nodes.first(); node; node = nodes.next() )
    node -> detach();
  emitRemoved (nodes());
  m_nodes.clear();
  m_node_map.clear();
  if ( key.isNull() )
  {
    if ( origin() && origin() -> canGroup() )
    {
      origin() -> release();
      setOrigin (0);
    }
    delete m_source;
    m_source = m_origin ?
        (KPlayerSource*) new KPlayerOriginSource (this)
      : (KPlayerSource*) new KPlayerStoreSource (this);
  }
  else
  {
    if ( ! origin() || ! origin() -> canGroup() )
    {
      delete m_source;
      m_source = new KPlayerGroupSource (this);
    }
    if ( ! origin() )
      setOrigin (createBranch (id()));
  }
  if ( populated() )
    doPopulate();
  else if ( groupsPopulated() )
    doPopulateGroups();
}
#endif

KPlayerPlaylistNode::~KPlayerPlaylistNode()
{
}

void KPlayerPlaylistNode::setupSource (void)
{
  m_duplicates = acceptsDuplicates();
  KPlayerGroupNode::setupSource();
  connect (configuration(), SIGNAL (updated()), SLOT (configurationUpdated()));
  if ( ! parent() -> parent() && id() == "playlists" && ! media() -> hasChildren() )
  {
    TQString group ("Playlist Entries");
    TDEConfig* meta = KPlayerEngine::engine() -> meta();
    meta -> setGroup (group);
    int entries = meta -> readNumEntry ("Entries");
    if ( entries )
    {
      KPlayerNode* np = parent() -> nodeById ("nowplaying");
      if ( np && ! np -> media() -> hasChildren() )
      {
        TQString name (i18n("My Playlist"));
        TQStringList children;
        children.append (name);
        media() -> setChildren (children);
        media() -> commit();
        TDEConfig* config = media() -> config();
        TQString urls (url (name).url());
        config -> setGroup (urls);
        for ( int i = 0; i < entries; i ++ )
        {
          TQString no (TQString::number (i));
          config -> writeEntry ("Child" + no, meta -> readEntry ("Entry " + no));
        }
        config -> writeEntry ("Children", entries);
        np -> media() -> setChildren (children);
        np -> media() -> commit();
        config -> setGroup (np -> url (name).url());
        config -> writeEntry ("Origin", urls);
      }
    }
    meta -> deleteGroup (group);
  }
}

void KPlayerPlaylistNode::setupOrigin (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerPlaylistNode::setupOrigin\n";
  if ( origin() )
    kdDebugTime() << " Origin " << origin() -> url() << "\n";
#endif
  KPlayerGroupNode::setupOrigin();
  if ( origin() && origin() -> hasProperties() )
  {
    media() -> setDefaultName (origin() -> name());
    connect (origin() -> parent(), SIGNAL (nodeUpdated (KPlayerContainerNode*, KPlayerNode*)),
      SLOT (originUpdated (KPlayerContainerNode*, KPlayerNode*)));
  }
}

void KPlayerPlaylistNode::originUpdated (KPlayerContainerNode*, KPlayerNode* node)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerPlaylistNode::originUpdated\n";
  kdDebugTime() << " Node   " << node -> url().url() << "\n";
#endif
  if ( node == origin() )
  {
#ifdef DEBUG_KPLAYER_NODE
    kdDebugTime() << " Name   " << name() << "\n";
#endif
    if ( name() != origin() -> name() )
    {
#ifdef DEBUG_KPLAYER_NODE
      kdDebugTime() << " Origin " << origin() -> name() << "\n";
#endif
      media() -> setName (origin() -> name());
#ifdef DEBUG_KPLAYER_NODE
      kdDebugTime() << " Name   " << name() << "\n";
#endif
    }
    media() -> commit();
  }
}

void KPlayerPlaylistNode::releaseOrigin (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerPlaylistNode::releaseOrigin\n";
#endif
  if ( origin() && origin() -> hasProperties() )
    disconnect (origin() -> parent(), SIGNAL (nodeUpdated (KPlayerContainerNode*, KPlayerNode*)),
      this, SLOT (originUpdated (KPlayerContainerNode*, KPlayerNode*)));
  KPlayerGroupNode::releaseOrigin();
}

TQString KPlayerPlaylistNode::icon (void) const
{
  return origin() ? origin() -> icon() : "folder_violet";
}

TQString KPlayerPlaylistNode::openIcon (void) const
{
  return origin() ? origin() -> icon() : "folder_violet_open";
}

bool KPlayerPlaylistNode::canLink (KPlayerContainerNode* node) const
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerPlaylistNode::canLink\n";
  kdDebugTime() << " Node   " << node -> url() << "\n";
#endif
  return node -> isCollection() || node -> isDirectory();
}

bool KPlayerPlaylistNode::isPlaylist (void) const
{
  return true;
}

bool KPlayerPlaylistNode::acceptsDuplicates (void) const
{
  return configuration() -> allowDuplicateEntries();
}

KPlayerContainerNode* KPlayerPlaylistNode::createBranch (const TQString& id, KPlayerContainerNode* origin)
{
  KPlayerContainerNode* node = new KPlayerPlaylistNode;
  node -> setup (this, id, origin);
  return node;
}

void KPlayerPlaylistNode::configurationUpdated (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerPlaylistNode::configurationUpdated\n";
#endif
  if ( ! acceptsDuplicates() && m_duplicates )
  {
    if ( populated() && ! origin() )
    {
      KPlayerNodeMap map;
      KPlayerNodeList list;
      KPlayerNodeListIterator iterator (nodes());
      while ( KPlayerNode* node = iterator.current() )
      {
        TQString id (node -> id().section ('#', 0, 0));
        KPlayerNodeMap::ConstIterator iterator = map.find (id);
        if ( iterator == map.end() )
          map.insert (id, node);
        else
          list.append (node);
        ++ iterator;
      }
      if ( ! list.isEmpty() )
        removed (list);
    }
    m_duplicates = false;
  }
}

KPlayerNowPlayingNode::~KPlayerNowPlayingNode()
{
}

KPlayerContainerNode* KPlayerNowPlayingNode::createBranch (const TQString& id, KPlayerContainerNode* origin)
{
  KPlayerContainerNode* node = new KPlayerNowPlayingNode;
  node -> setup (this, id, origin);
  return node;
}

bool KPlayerNowPlayingNode::canLink (KPlayerContainerNode* node) const
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerNowPlayingNode::canLink\n";
  kdDebugTime() << " Node   " << node -> url() << "\n";
#endif
  return node -> isCollection() || node -> isDirectory() || node -> hasProperties()
    || node -> isPlaylist() && ! node -> isRecent() && ! node -> isNowPlaying();
}

bool KPlayerNowPlayingNode::isNowPlaying (void) const
{
  return true;
}

TQString KPlayerNowPlayingNode::icon (void) const
{
  return origin() ? origin() -> icon() : "folder_red";
}

TQString KPlayerNowPlayingNode::openIcon (void) const
{
  return origin() ? origin() -> icon() : "folder_red_open";
}

void KPlayerNowPlayingNode::setupOrigin (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerNowPlayingNode::setupOrigin\n";
  if ( origin() )
    kdDebugTime() << " Origin " << origin() -> url() << "\n";
#endif
  KPlayerPlaylistNode::setupOrigin();
  if ( origin() && origin() -> hasProperties() && ((KPlayerDeviceNode*) origin()) -> diskDevice() )
  {
    KPlayerDiskNode* disk = (KPlayerDiskNode*) origin();
    if ( disk -> dataDisk() )
      if ( disk -> hasLocalPath() )
      {
        KPlayerContainerNode* origin = root() -> getNodeByUrl (KURL::fromPathOrURL (disk -> localPath()));
        if ( origin )
        {
          disconnect (m_origin -> parent(), SIGNAL (nodeUpdated (KPlayerContainerNode*, KPlayerNode*)),
            this, SLOT (originUpdated (KPlayerContainerNode*, KPlayerNode*)));
          m_origin -> reference();
          m_origin -> release();
          setOrigin (origin);
        }
      }
      else
        disk -> getLocalPath();
  }
}

void KPlayerNowPlayingNode::originUpdated (KPlayerContainerNode*, KPlayerNode* node)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerNowPlayingNode::originUpdated\n";
  kdDebugTime() << " Node   " << node -> url().url() << "\n";
#endif
  if ( node == origin() && node -> hasProperties() && ((KPlayerDeviceNode*) node) -> diskDevice() )
  {
#ifdef DEBUG_KPLAYER_NODE
    kdDebugTime() << " Name   " << name() << "\n";
#endif
    if ( name() != origin() -> name() )
    {
#ifdef DEBUG_KPLAYER_NODE
      kdDebugTime() << " Origin " << origin() -> name() << "\n";
#endif
      media() -> setName (origin() -> name());
#ifdef DEBUG_KPLAYER_NODE
      kdDebugTime() << " Name   " << name() << "\n";
#endif
    }
    KPlayerDiskNode* disk = (KPlayerDiskNode*) node;
    if ( disk -> dataDisk() )
      if ( disk -> hasLocalPath() )
      {
        KPlayerContainerNode* origin = root() -> getNodeByUrl (KURL::fromPathOrURL (disk -> localPath()));
        if ( origin )
        {
          disconnect (node -> parent(), SIGNAL (nodeUpdated (KPlayerContainerNode*, KPlayerNode*)),
            this, SLOT (originUpdated (KPlayerContainerNode*, KPlayerNode*)));
          node -> release();
          origin -> reference();
          setOrigin (origin);
          if ( groupsPopulated() )
          {
            disk -> vacateGroups();
            origin -> populateGroups();
          }
          if ( populated() )
          {
            disk -> vacate();
            origin -> populate();
          }
          added (origin, true);
          media() -> commit();
        }
      }
      else
        disk -> getLocalPath();
    media() -> commit();
  }
}

KPlayerRecentNode::~KPlayerRecentNode()
{
}

bool KPlayerRecentNode::isRecent (void) const
{
  return true;
}

bool KPlayerRecentNode::canLink (KPlayerContainerNode* node) const
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerRecentNode::canLink\n";
  kdDebugTime() << " Node   " << node -> url() << "\n";
#endif
  return node -> isCollection() || node -> isDirectory() || node -> hasProperties()
    || node -> isPlaylist() && ! node -> isRecent() && ! node -> isNowPlaying();
}

KPlayerContainerNode* KPlayerRecentNode::createBranch (const TQString& id, KPlayerContainerNode* origin)
{
  KPlayerContainerNode* node = new KPlayerRecentNode;
  node -> setup (this, id, origin);
  return node;
}

TQString KPlayerRecentNode::icon (void) const
{
  return origin() ? origin() -> icon() : "folder_red";
}

TQString KPlayerRecentNode::openIcon (void) const
{
  return origin() ? origin() -> icon() : "folder_red_open";
}

KPlayerRecentsNode::~KPlayerRecentsNode()
{
}

void KPlayerRecentsNode::setupSource (void)
{
  KPlayerRecentNode::setupSource();
  if ( ! media() -> hasChildren() )
  {
    TQString group ("Recent Files");
    TDEConfig* config = KPlayerEngine::engine() -> config();
    config -> setGroup (group);
    int limit = configuration() -> recentListSize();
    TQStringList children;
    for ( int i = 1; i <= limit; i ++ )
    {
      TQString name (config -> readEntry ("File" + TQString::number (i)));
      if ( name.isEmpty() )
        break;
      children.append (name);
    }
    if ( ! children.isEmpty() )
    {
      media() -> setChildren (children);
      setCustomOrder (true);
    }
    config -> deleteGroup (group);
  }
}

void KPlayerRecentsNode::addRecent (const KPlayerNodeList& list)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerRecentsNode::addRecent\n";
#endif
  if ( configuration() -> recentListSize() > 0 && ! list.isEmpty() )
  {
    populate();
    bool just_move = true;
    KPlayerNodeListIterator iterator (list);
    while ( KPlayerNode* node = iterator.current() )
    {
      if ( node -> parent() != this )
      {
        just_move = false;
        break;
      }
      ++ iterator;
    }
    if ( just_move )
      move (list, this);
    else if ( list.count() == 1 )
    {
      KPlayerNode* listnode = list.getFirst();
      bool container = listnode -> isContainer();
      KPlayerNodeList previous;
      KPlayerNodeListIterator iterator (nodes());
      while ( KPlayerNode* node = iterator.current() )
      {
        if ( container && node -> isContainer() && ((KPlayerContainerNode*) node) -> origin() == listnode
            || ! container && ! node -> isContainer() && node -> media() == listnode -> media() )
          previous.append (node);
        ++ iterator;
      }
      if ( ! previous.isEmpty() )
        remove (previous);
      prepend (list);
      if ( container && ! listnode -> hasProperties() )
      {
        KPlayerNode* firstnode = nodes().getFirst();
        firstnode -> media() -> setName (i18n("%1 in %2").arg (listnode -> name(), listnode -> parent() -> name()));
        firstnode -> media() -> commit();
      }
    }
    else
    {
      TQString name (list.count() == 2 ? i18n("%1 and %2").arg (list.getFirst() -> name(), list.getLast() -> name())
        : i18n("%1 and %2 more").arg (list.getFirst() -> name(), TQString::number (list.count() - 1)));
      TQString id (name);
      for ( int i = 0; nodeById (id); i ++ )
        id = name + TQString::number (i);
      prependBranch (id);
      KPlayerContainerNode* container = getNodeById (id);
      container -> media() -> setName (name);
      container -> prepend (list);
    }
    configurationUpdated();
    vacate();
  }
}

void KPlayerRecentsNode::configurationUpdated (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerRecentsNode::configurationUpdated\n";
#endif
  KPlayerPlaylistNode::configurationUpdated();
  int limit = configuration() -> recentListSize();
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << " Limit  " << limit << "\n";
#endif
  populate();
  if ( int (nodes().count()) > limit )
  {
    limit = nodes().count() - limit;
    m_nodes.last();
    KPlayerNodeList list;
    for ( int i = 0; i < limit; i ++ )
    {
      list.append (m_nodes.current());
      m_nodes.prev();
    }
    remove (list);
  }
  vacate();
}

KPlayerDevicesNode::~KPlayerDevicesNode()
{
}

void KPlayerDevicesNode::setupSource (void)
{
  m_complete = false;
  m_directory = "/dev";
  m_directory.setFilter (TQDir::All | TQDir::System);
  m_directory.setSorting (TQDir::Name);
  m_watch.addDir (m_directory.path());
  m_watch.startScan();
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << " Path   " << m_directory.path() << "\n";
  kdDebugTime() << " Method " << m_watch.internalMethod() << "\n";
#endif
  connect (&m_watch, SIGNAL (dirty (const TQString&)), SLOT (dirty (const TQString&)));
  connect (&m_lister, SIGNAL (completed()), SLOT (completed()));
  connect (&m_lister, SIGNAL (newItems (const KFileItemList&)), SLOT (refresh (const KFileItemList&)));
  connect (&m_lister, SIGNAL (deleteItem (KFileItem*)), SLOT (removed (KFileItem*)));
  TQStringList mimetypes;
  mimetypes.append ("media/audiocd");
  mimetypes.append ("media/cdrom_mounted");
  mimetypes.append ("media/cdrom_unmounted");
  mimetypes.append ("media/cdwriter_mounted");
  mimetypes.append ("media/cdwriter_unmounted");
  mimetypes.append ("media/dvd_mounted");
  mimetypes.append ("media/dvd_unmounted");
  mimetypes.append ("media/dvdvideo");
  mimetypes.append ("media/svcd");
  mimetypes.append ("media/vcd");
  m_lister.setMimeFilter (mimetypes);
  m_lister.setAutoErrorHandlingEnabled (false, 0);
  m_lister.openURL ("media:/");
  m_source = new KPlayerDevicesSource (this);
}

KPlayerContainerNode* KPlayerDevicesNode::createBranch (const TQString& id, KPlayerContainerNode* origin)
{
  TQMap<TQString, TQString>::ConstIterator iterator = m_type_map.find (id);
  TQString type (iterator == m_type_map.end() ? media() -> type (id) : iterator.data());
  KPlayerDeviceNode* node = type == "TV" ? (KPlayerDeviceNode*) new KPlayerTVNode
    : type == "DVB" ? (KPlayerDeviceNode*) new KPlayerDVBNode : (KPlayerDeviceNode*) new KPlayerDiskNode;
  node -> setup (this, id, origin);
  return node;
}

TQString KPlayerDevicesNode::icon (void) const
{
  return "system";
}

TQString KPlayerDevicesNode::openIcon (void) const
{
  return "system";
}

bool KPlayerDevicesNode::isDevices (void) const
{
  return true;
}

bool KPlayerDevicesNode::canRename (void) const
{
  return false;
}

bool KPlayerDevicesNode::canSaveAsPlaylist (void) const
{
  return false;
}

KPlayerContainerNode* KPlayerDevicesNode::getNodeByPath (const TQString& path)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerDevicesNode::getNodeByPath\n";
  kdDebugTime() << " Path   " << path << "\n";
#endif
  return getNodeById ("/" + path);
}

void KPlayerDevicesNode::dirty (const TQString&)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerDevicesNode::dirty\n";
#endif
  TQStringList current, previous;
  update (current, previous);
  addedBranches (current);
  if ( ! previous.isEmpty() )
    KPlayerContainerNode::removed (previous);
}

void KPlayerDevicesNode::update (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerDevicesNode::update\n";
#endif
  TQStringList current, previous;
  update (current, previous);
}

void KPlayerDevicesNode::update (TQStringList& current, TQStringList& previous)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerDevicesNode::update\n";
  kdDebugTime() << " URL    " << url() << "\n";
#endif
  const char* paths[] = { "/dev", "/dev", "/dev", "/dev/dvb" };
  const char* globs[] = { "cdr*", "dvd*", "video*", "adapter*" };
  const char* types[] = { I18N_NOOP("CD"), I18N_NOOP("DVD"), I18N_NOOP("TV"), I18N_NOOP("DVB") };
  TQMap<TQString, int> maps [sizeof (paths) / sizeof (const char*)];
  previous = m_devices;
  for ( uint i = 0; i < sizeof (paths) / sizeof (const char*); i ++ )
  {
    TQDir dir (paths[i], globs[i], TQDir::Unsorted, TQDir::All | TQDir::System);
    const TQFileInfoList* list = dir.entryInfoList();
    if ( list )
      for ( TQFileInfoListIterator filit (*list); filit.current(); ++ filit )
      {
        TQFileInfo* info = filit.current();
        TQString name (info -> fileName());
        if ( info -> exists() && info -> isReadable() )
        {
          TQString path (info -> filePath());
#ifdef DEBUG_KPLAYER_NODE
          kdDebugTime() << " Device " << path << "\n";
#endif
          for ( int l = 0; info -> isSymLink() && l < 5; l ++ )
          {
            path = info -> readLink();
#ifdef DEBUG_KPLAYER_NODE
            kdDebugTime() << " Link to " << path << "\n";
#endif
            path = dir.filePath (path);
#ifdef DEBUG_KPLAYER_NODE
            kdDebugTime() << " Absolute " << path << "\n";
#endif
            path = TQDir::cleanDirPath (path);
#ifdef DEBUG_KPLAYER_NODE
            kdDebugTime() << " Cleaned " << path << "\n";
#endif
            info -> setFile (path);
          }
#ifdef DEBUG_KPLAYER_NODE
          kdDebugTime() << " ID     " << path << "\n";
#endif
          if ( ! media() -> hidden (path) )
          {
            TQRegExp re_no ("(\\d+)$");
            int no = re_no.search (name) >= 0 ? re_no.cap(1).toInt() : -1;
#ifdef DEBUG_KPLAYER_NODE
            kdDebugTime() << " Number " << no << "\n";
#endif
            if ( i == 2 )
            {
              KDE_struct_stat st;
              if ( KDE_lstat (path.latin1(), &st) != 0 )
                continue;
#ifdef DEBUG_KPLAYER_NODE
              kdDebugTime() << " Device " << st.st_dev << "\n";
              kdDebugTime() << " Major  " << major (st.st_dev) << "\n";
              kdDebugTime() << " Minor  " << minor (st.st_dev) << "\n";
              kdDebugTime() << " RDev   " << st.st_rdev << "\n";
              kdDebugTime() << " Major  " << major (st.st_rdev) << "\n";
              kdDebugTime() << " Minor  " << minor (st.st_rdev) << "\n";
#endif
              if ( major (st.st_rdev) != 81 )
                continue;
            }
            for ( uint j = 0; j < i; j ++ )
              maps[j].remove (path);
            maps[i].insert (path, no);
            if ( m_type_map.contains (path) )
            {
              previous.remove (path);
              m_type_map [path] = types[i];
#ifdef DEBUG_KPLAYER_NODE
              kdDebugTime() << " Found  " << path << " " << types[i] << "\n";
#endif
            }
            else
            {
              current.append (path);
              m_devices.append (path);
              m_type_map.insert (path, types[i]);
#ifdef DEBUG_KPLAYER_NODE
              kdDebugTime() << " Added  " << path << " " << types[i] << "\n";
#endif
            }
          }
        }
      }
  }
  TQStringList::ConstIterator slit (previous.begin());
  while ( slit != previous.end() )
  {
    m_devices.remove (*slit);
    m_type_map.remove (*slit);
    ++ slit;
  }
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << " CDs    " << maps[0].count() << "\n";
  kdDebugTime() << " DVDs   " << maps[1].count() << "\n";
  kdDebugTime() << " TVs    " << maps[2].count() << "\n";
  kdDebugTime() << " DVBs   " << maps[3].count() << "\n";
  kdDebugTime() << " Added  " << current.count() << "\n";
  kdDebugTime() << " Removed " << previous.count() << "\n";
  kdDebugTime() << " Devices " << m_devices.count() << "\n";
#endif
  m_name_map.clear();
  addToNameMap (maps[0], i18n("CD Device"), i18n("CD Device %1"));
  addToNameMap (maps[1], i18n("DVD Device"), i18n("DVD Device %1"));
  addToNameMap (maps[2], i18n("TV Device"), i18n("TV Device %1"));
  addToNameMap (maps[3], i18n("DVB Device"), i18n("DVB Device %1"));
}

void KPlayerDevicesNode::addToNameMap (TQMap<TQString, int>& map, const TQString& device, const TQString& deviceno)
{
  if ( map.count() == 1 )
    m_name_map.insert (map.begin().key(), device);
  else if ( map.count() > 1 )
  {
    int index = 0;
    bool found;
    do
    {
      found = false;
      TQMap<TQString, int>::Iterator imit (map.begin());
      while ( imit != map.end() )
      {
        if ( imit.data() == index )
        {
          m_name_map.insert (imit.key(), deviceno.arg (index));
          map.remove (imit);
          found = true;
          break;
        }
        ++ imit;
      }
      ++ index;
    }
    while ( found || index == 1 );
    if ( map.count() == 1 )
      m_name_map.insert (map.begin().key(), device);
    else
    {
      TQMap<TQString, int>::ConstIterator imit (map.begin());
      while ( imit != map.end() )
      {
        m_name_map.insert (imit.key(), deviceno.arg (index));
        ++ index;
        ++ imit;
      }
    }
  }
}

void KPlayerDevicesNode::completed (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerDevicesNode::completed\n";
#endif
  refresh (m_lister.items());
  m_complete = true;
}

void KPlayerDevicesNode::refreshItem (KFileItem* item)
{
  TQString path ("/dev" + item -> url().path());
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerDevicesNode::refreshItem\n";
  kdDebugTime() << " Item   " << item -> url() << "\n";
  kdDebugTime() << " Type   " << item -> mimetype() << "\n";
  kdDebugTime() << " Text   " << item -> text() << "\n";
  kdDebugTime() << " Name   " << item -> name() << "\n";
  kdDebugTime() << " Local  " << itemLocalPath (*item) << "\n";
  kdDebugTime() << " Comment " << item -> mimeComment() << "\n";
  kdDebugTime() << " Icon   " << item -> iconName() << "\n";
  kdDebugTime() << " URL    " << item -> url().url() << "\n";
  kdDebugTime() << " Permissions " << item -> permissions() << "\n";
  kdDebugTime() << " Mode   " << item -> mode() << "\n";
  kdDebugTime() << " User   " << item -> user() << "\n";
  kdDebugTime() << " Group  " << item -> group() << "\n";
  kdDebugTime() << " Size   " << item -> size() << "\n";
  kdDebugTime() << " Modification Time " << item -> time (TDEIO::UDS_MODIFICATION_TIME) << "\n";
  kdDebugTime() << " Access Time " << item -> time (TDEIO::UDS_ACCESS_TIME) << "\n";
  kdDebugTime() << " Creation Time " << item -> time (TDEIO::UDS_CREATION_TIME) << "\n";
  kdDebugTime() << " Overlays " << item -> overlays() << "\n";
  kdDebugTime() << " Status " << item -> getStatusBarInfo() << "\n";
  kdDebugTime() << " Drops  " << item -> acceptsDrops() << "\n";
  kdDebugTime() << " Marked " << item -> isMarked() << "\n";
  kdDebugTime() << " Path   " << path << "\n";
#endif
  TQString type (item -> mimetype() == "media/audiocd" ? I18N_NOOP("Audio CD")
    : item -> mimetype() == "media/dvdvideo" ? "DVD"
    : item -> mimetype() == "media/svcd" || item -> mimetype() == "media/vcd" ? I18N_NOOP("Video CD")
    : item -> mimetype().startsWith ("media/dvd") ? I18N_NOOP("Data DVD") : I18N_NOOP("Data CD"));
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << " Type   " << type << "\n";
#endif
  m_disk_types.insert (path, type);
  KPlayerDeviceNode* node = nodeById (path);
  if ( node && node -> diskDevice() )
  {
    KPlayerDiskNode* disk = (KPlayerDiskNode*) node;
    disk -> diskInserted (itemLocalPath (*item));
    /*if ( type == "DVD" )
    {
      TQString name (item -> name());
#ifdef DEBUG_KPLAYER_NODE
      kdDebugTime() << " Name   " << name << "\n";
#endif
      if ( ! name.isEmpty() && disk -> disk() && disk -> disk() -> name() == disk -> disk() -> defaultName() )
      {
        bool inword = false, capsonly = true;
        int i, length = name.length();
        for ( i = 0; i < length; ++ i )
        {
          TQChar c = name.constref (i);
          if ( c.upper() != c )
          {
            capsonly = false;
            break;
          }
        }
        for ( i = 0; i < length; ++ i )
        {
          TQChar& c = name.ref (i);
          if ( c == '_' )
            c = ' ';
          else if ( inword && c.isLetter() )
            c = c.lower();
          inword = c.isLetter();
        }
#ifdef DEBUG_KPLAYER_NODE
        kdDebugTime() << " Title  " << name << "\n";
#endif
        disk -> disk() -> setName (name);
        disk -> disk() -> commit();
      }
    }*/
  }
}

void KPlayerDevicesNode::refresh (const KFileItemList& items)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerDevicesNode::refresh\n";
#endif
  KFileItemListIterator iterator (items);
  while ( KFileItem* item = iterator.current() )
  {
    refreshItem (item);
    ++ iterator;
  }
}

void KPlayerDevicesNode::removed (KFileItem* item)
{
  TQString path ("/dev" + item -> url().path());
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerDevicesNode::removed\n";
  kdDebugTime() << " Item   " << item -> url() << "\n";
  kdDebugTime() << " Type   " << item -> mimetype() << "\n";
  kdDebugTime() << " Text   " << item -> text() << "\n";
  kdDebugTime() << " Name   " << item -> name() << "\n";
  kdDebugTime() << " Local  " << itemLocalPath (*item) << "\n";
  kdDebugTime() << " Comment " << item -> mimeComment() << "\n";
  kdDebugTime() << " Icon   " << item -> iconName() << "\n";
  kdDebugTime() << " Path   " << path << "\n";
#endif
  m_disk_types.remove (path);
  KPlayerDeviceNode* node = nodeById (path);
  if ( node && node -> diskDevice() )
    ((KPlayerDiskNode*) node) -> diskRemoved();
}

void KPlayerDevicesNode::removed (const KPlayerNodeList& nodes)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerDevicesNode::removed\n";
#endif
  KPlayerNodeListIterator nlit (nodes);
  while ( KPlayerNode* node = nlit.current() )
  {
    TQString id (node -> id());
    m_devices.remove (id);
    m_type_map.remove (id);
    m_disk_types.remove (id);
    ++ nlit;
  }
  KPlayerContainerNode::removed (nodes);
}

KPlayerDeviceNode::~KPlayerDeviceNode()
{
}

TQString KPlayerDeviceNode::icon (void) const
{
  return "tv";
}

TQString KPlayerDeviceNode::openIcon (void) const
{
  return icon();
}

bool KPlayerDeviceNode::hasProperties (void) const
{
  return true;
}

bool KPlayerDeviceNode::allowsCustomOrder (void) const
{
  return false;
}

bool KPlayerDeviceNode::diskDevice (void)
{
  return false;
}

void KPlayerDeviceNode::removed (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerDeviceNode::removed\n";
  kdDebugTime() << " URL    " << metaurl().url() << "\n";
#endif
  KPlayerContainerNode::removed();
  parent() -> media() -> setHidden (id(), true);
}

KPlayerDiskNode::~KPlayerDiskNode()
{
  if ( disk() )
    KPlayerMedia::release (device());
}

void KPlayerDiskNode::setupMedia (void)
{
  m_fast_autodetect = false;
  m_media = m_device = KPlayerMedia::deviceProperties (metaurl());
  m_disk = 0;
  if ( ! media() -> hasType() )
    media() -> setType (parent() -> deviceType (id()));
  media() -> setDefaultName (parent() -> deviceName (id()));
  diskInserted();
  if ( ! disk() )
    connect (media(), SIGNAL (updated()), SLOT (updated()));
}

void KPlayerDiskNode::setupSource (void)
{
  m_source = new KPlayerDiskSource (this);
}

KPlayerNode* KPlayerDiskNode::createLeaf (const TQString& id)
{
  if ( disk() && disk() -> type() == "Video CD" && disk() -> msf (id) == 6 )
    return 0;
  KPlayerNode* node = new KPlayerTrackNode;
  node -> setup (this, id);
  return node;
}

TQString KPlayerDiskNode::icon (void) const
{
  const TQString& type (media() -> type());
  return type == "DVD" ? "dvd_unmount" : type == "Audio CD" ? "cdaudio_unmount" : "cdrom_unmount";
}

bool KPlayerDiskNode::ready (void) const
{
  return m_url.isNull() && (KPlayerEngine::engine() -> process() -> state() == KPlayerProcess::Idle
    || KPlayerEngine::engine() -> properties() -> parent() != disk());
}

TQString KPlayerDiskNode::suggestId (void) const
{
  return media() -> url().fileName();
}

void KPlayerDiskNode::setDiskType (const TQString& type)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerDiskNode::setDiskType\n";
  kdDebugTime() << " Type   " << type << "\n";
#endif
  disk() -> setType (type);
  disk() -> setDefaultName (i18n("%1 in %2").arg (i18n(type.utf8()), device() -> name()));
}

bool KPlayerDiskNode::diskDevice (void)
{
  return true;
}

bool KPlayerDiskNode::mediaDisk (void)
{
  return disk() && disk() -> hasType() && ! disk() -> type().startsWith ("Data ");
}

bool KPlayerDiskNode::dataDisk (void)
{
  return disk() && disk() -> type().startsWith ("Data ");
}

static TQRegExp re_track_length ("^ID_(?:DVD_TITLE|VCD_TRACK|CDDA_TRACK)_(\\d+)_(?:LENGTH|MSF)=([0-9.:]+)$");

bool KPlayerDiskNode::accessDisk (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerDiskNode::accessDisk\n";
  kdDebugTime() << " URL    " << url() << "\n";
  kdDebugTime() << " Path   " << id() << "\n";
#endif
  TQFile file (id());
  if ( file.open (IO_ReadOnly) )
  {
    char data [65536];
    int length = file.readBlock (data, sizeof (data));
    file.close();
#ifdef DEBUG_KPLAYER_NODE
    kdDebugTime() << " Length " << length << "\n";
#endif
    if ( length > 0 )
    {
      KMD5 digest (data, length);
      diskDetected (digest.hexDigest());
      return true;
    }
  }
  return false;
}

void KPlayerDiskNode::diskDetected (const TQString& diskid)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerDiskNode::diskDetected\n";
  kdDebugTime() << " ID     " << diskid << "\n";
#endif
  if ( diskid == suggestId() )
    return;
  KPlayerContainerNode::removed (nodes());
  KPlayerGenericProperties* previous = media();
  previous -> disconnect (this);
  m_media = m_disk = KPlayerMedia::diskProperties (m_device, "kplayer:/disks/" + diskid);
  connect (media(), SIGNAL (updated()), SLOT (updated()));
  const TQString& type (parent() -> diskType (id()));
  if ( type.isNull() )
    disk() -> setDefaultName (i18n("Disk in %2").arg (device() -> name()));
  else
    setDiskType (type);
  if ( previous != device() && previous -> url().url().find ('/', 15) >= 0
      && previous -> name() != previous -> defaultName() && media() -> name() == media() -> defaultName() )
    media() -> setName (previous -> name());
  media() -> diff (previous);
  media() -> commit();
  if ( previous != device() )
    KPlayerMedia::release (previous);
}

void KPlayerDiskNode::diskInserted (const TQString& path)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerDiskNode::diskInserted\n";
#endif
  const TQString& type (parent() -> diskType (id()));
  if ( type.isNull() )
    return;
  m_fast_autodetect = true;
  m_local_path = path;
  if ( disk() )
  {
    if ( disk() -> type() != type )
    {
      KPlayerContainerNode::removed (nodes());
      KPlayerMedia* previous = media();
      previous -> disconnect (this);
      TQString urls ("kplayer:/disks" + id());
      KPlayerEngine::engine() -> meta() -> deleteGroup (urls);
      m_media = m_disk = KPlayerMedia::diskProperties (m_device, urls);
      connect (media(), SIGNAL (updated()), SLOT (updated()));
      setDiskType (type);
      media() -> diff (previous);
      if ( previous != device() )
        KPlayerMedia::release (previous);
    }
    else
      disk() -> commit();
  }
  else
  {
#ifdef DEBUG_KPLAYER_NODE
    kdDebugTime() << " Type   " << type << "\n";
#endif
    media() -> disconnect (this);
    TQString urls ("kplayer:/disks" + id());
    KPlayerEngine::engine() -> meta() -> deleteGroup (urls);
    m_media = m_disk = KPlayerMedia::diskProperties (device(), urls);
    connect (media(), SIGNAL (updated()), SLOT (updated()));
    setDiskType (type);
    media() -> diff (device());
  }
  if ( populated() && ready() && mediaDisk() && ! disk() -> hasTracks() )
    autodetect();
}

void KPlayerDiskNode::diskRemoved (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerDiskNode::diskRemoved\n";
#endif
  m_fast_autodetect = false;
  m_local_path = TQString::null;
  m_url = TQString::null;
  if ( disk() )
  {
    KPlayerContainerNode::removed (nodes());
    media() -> disconnect (this);
    KPlayerDiskProperties* d = disk();
    m_disk = 0;
    m_media = device();
    connect (media(), SIGNAL (updated()), SLOT (updated()));
    media() -> diff (d);
    KPlayerMedia::release (d);
  }
  else
    media() -> commit();
}

void KPlayerDiskNode::getLocalPath (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerDiskNode::getLocalPath\n";
#endif
  if ( hasLocalPath() || ! dataDisk() || ! ready() )
    return;
  m_url = "list://";
  TDEIO::ListJob* job = TDEIO::listDir ("media:/" + url().fileName(), false, false);
  connect (job, SIGNAL(result(TDEIO::Job*)), SLOT(listResult(TDEIO::Job*)));
}

void KPlayerDiskNode::listResult (TDEIO::Job* job)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerDiskNode::listResult\n";
#endif
  if ( job -> error() )
  {
#ifdef DEBUG_KPLAYER_NODE
    kdDebugTime() << " Error  " << job -> error() << " " << job -> errorString() << "\n";
#endif
    m_url = "mount://";
    TDEIO::SimpleJob* job = TDEIO::mount (true, 0, id(), TQString::null, false);
    connect (job, SIGNAL(result(TDEIO::Job*)), SLOT(mountResult(TDEIO::Job*)));
  }
  else
  {
    m_url = "path://";
    TDEIO::StatJob* job = TDEIO::stat ("media:/" + url().fileName(), false);
    connect (job, SIGNAL(result(TDEIO::Job*)), SLOT(pathResult(TDEIO::Job*)));
  }
}

void KPlayerDiskNode::mountResult (TDEIO::Job* job)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerDiskNode::mountResult\n";
  if ( job -> error() )
    kdDebugTime() << " Error  " << job -> error() << " " << job -> errorString() << "\n";
#endif
  m_url = "path://";
  job = TDEIO::stat ("media:/" + url().fileName(), false);
  connect (job, SIGNAL(result(TDEIO::Job*)), SLOT(pathResult(TDEIO::Job*)));
}

void KPlayerDiskNode::pathResult (TDEIO::Job* job)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerDiskNode::pathResult\n";
#endif
  m_url = TQString::null;
  if ( job -> error() )
  {
#ifdef DEBUG_KPLAYER_NODE
    kdDebugTime() << " Error  " << job -> error() << " " << job -> errorString() << "\n";
#endif
    if ( disk() )
      disk() -> commit();
  }
  else
  {
    KFileItem item (((TDEIO::StatJob*) job) -> statResult(), "media:/" + url().fileName());
    if ( ! itemLocalPath (item).isEmpty() )
      parent() -> refreshItem (&item);
  }
}

int KPlayerDiskNode::tracks (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerDiskNode::tracks\n";
#endif
  int n = disk() ? disk() -> tracks() : 0;
  if ( n == 0 && ready() && ! dataDisk() )
  {
    autodetect();
    if ( disk() )
      n = disk() -> tracks();
  }
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << " Tracks " << n << "\n";
#endif
  return n;
}

void KPlayerDiskNode::loadDisk (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerDiskNode::loadDisk\n";
#endif
  if ( ready() && disk() && disk() -> hasTracks() )
    diskRemoved();
  if ( ready() )
    autodetect();
}

void KPlayerDiskNode::autodetect (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerDiskNode::autodetect\n";
  kdDebugTime() << " Fast   " << m_fast_autodetect << "\n";
  if ( disk() && disk() -> hasType() )
    kdDebugTime() << " Type   " << disk() -> type() << "\n";
#endif
  m_autodetected = false;
  m_detected_tracks = 0;
  m_track_lengths.clear();
  m_disk_id = TQString::null;
  m_local_path = TQString::null;
  if ( ! disk() || ! disk() -> hasType() )
    m_fast_autodetect = false;
  if ( ! m_fast_autodetect && ready() || m_fast_autodetect && disk() -> type() == "DVD" && m_url != "dvd://" )
    m_url = "dvd://";
  else if ( ! m_fast_autodetect && m_url == "dvd://"
      || m_fast_autodetect && disk() -> type() == "Audio CD" && m_url != "cdda://" )
    m_url = "cdda://";
  else if ( ! m_fast_autodetect && m_url == "cdda://"
    || m_fast_autodetect && disk() -> type().startsWith ("Data ") && m_url != "data://" )
  {
    m_url = "data://";
    TDEIO::StatJob* job = TDEIO::stat ("media:/" + url().fileName(), false);
    connect (job, SIGNAL(result(TDEIO::Job*)), SLOT(statResult(TDEIO::Job*)));
    return;
  }
  else if ( ! m_fast_autodetect && m_url == "data://"
      || m_fast_autodetect && disk() -> type() == "Video CD" && m_url != "vcd://" )
    m_url = "vcd://";
  else
  {
    diskRemoved();
    return;
  }
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << " URL    " << m_url << "\n";
#endif
  KPlayerLineOutputProcess* process = new KPlayerLineOutputProcess;
  *process << media() -> executablePath() << (m_url == "dvd://" ? "-dvd-device" : "-cdrom-device") << id()
    << "-msglevel" << "identify=6" << "-ao" << "null" << "-vo" << "null" << "-frames" << "0";
  if ( m_url == "vcd://" )
    *process << "vcd://1" << "vcd://2";
  else
    *process << m_url;
  connect (process, SIGNAL (receivedStdoutLine (KPlayerLineOutputProcess*, char*, int)),
    SLOT (receivedOutput (KPlayerLineOutputProcess*, char*, int)));
  connect (process, SIGNAL (processExited (TDEProcess*)), SLOT (processExited (TDEProcess*)));
  process -> start (TDEProcess::NotifyOnExit, TDEProcess::All);
}

void KPlayerDiskNode::receivedOutput (KPlayerLineOutputProcess*, char* str, int)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << " <<<<<< " << str << "\n";
#endif
  static TQRegExp re_tracks ("^ID_(?:DVD_TITLES|VCD_END_TRACK|CDDA_TRACKS)=(\\d+)$");
  static TQRegExp re_msf ("^(\\d+):(\\d+):(\\d+)$");
  static TQRegExp re_filename ("^ID_FILENAME=");
  if ( m_detected_tracks == 0 && re_tracks.search (str) >= 0 )
    m_detected_tracks = re_tracks.cap(1).toUInt();
  else if ( m_detected_tracks && re_filename.search (str) >= 0 )
    m_autodetected = true;
  else if ( m_track_lengths.count() < m_detected_tracks && re_track_length.search (str) >= 0 )
  {
    uint track = re_track_length.cap(1).toUInt() - 1;
    if ( track == m_track_lengths.count() )
    {
      TQString length (re_track_length.cap(2));
      if ( m_url == "cdda://" )
        m_disk_id += length;
      if ( m_url == "dvd://" )
        m_track_lengths.append (length.toFloat());
      else if ( re_msf.search (length) >= 0 )
        m_track_lengths.append (re_msf.cap(1).toInt() * 60 + re_msf.cap(2).toInt() + re_msf.cap(3).toFloat() / 75);
    }
  }
}

void KPlayerDiskNode::processExited (TDEProcess* process)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerDiskNode::processExited\n";
#endif
  delete process;
  if ( ready() )
    return;
  if ( m_autodetected && m_url == "cdda://" )
  {
#ifdef DEBUG_KPLAYER_NODE
    kdDebugTime() << " Length " << m_disk_id.length() << "\n";
#endif
    KMD5 digest (m_disk_id.latin1());
    diskDetected (digest.hexDigest());
    autodetected();
    m_artist = m_album = m_genre = m_cddb_id = TQString::null;
    m_year = 0;
    KPlayerLineOutputProcess* process = new KPlayerLineOutputProcess;
    *process << media() -> executablePath() << "-cdrom-device" << id() << "-v"
      << "-identify" << "-ao" << "null" << "-vo" << "null" << "-frames" << "0" << "cddb://";
    connect (process, SIGNAL (receivedStdoutLine (KPlayerLineOutputProcess*, char*, int)),
      SLOT (receivedCddbOutput (KPlayerLineOutputProcess*, char*, int)));
    connect (process, SIGNAL (processExited (TDEProcess*)), SLOT (cddbProcessExited (TDEProcess*)));
    process -> start (TDEProcess::NotifyOnExit, TDEProcess::All);
    return;
  }
  if ( m_autodetected || m_url == "cdda://" && ! m_fast_autodetect )
    if ( ! accessDisk() )
    {
      diskRemoved();
      return;
    }
    else if ( dataDisk() || mediaDisk() && disk() -> hasTracks() )
    {
      setDiskType (disk() -> type());
      updateTracks();
      m_url = TQString::null;
      disk() -> commit();
      return;
    }
  if ( m_autodetected && disk() )
    autodetected();
  else if ( m_url != "vcd://" || m_fast_autodetect && disk() && disk() -> hasType() )
    autodetect();
  else
  {
    m_url = TQString::null;
    if ( disk() )
    {
      setDiskType (I18N_NOOP("Data Disk"));
      disk() -> commit();
    }
  }
}

void KPlayerDiskNode::autodetected (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerDiskNode::autodetected\n";
#endif
  TQString type (m_url == "cdda://" ? "Audio CD" : m_url == "dvd://" ? "DVD"
    : m_url == "vcd://" ? "Video CD" : disk() -> type());
  setDiskType (type);
  if ( m_detected_tracks )
    disk() -> setTracks (m_detected_tracks);
  updateTracks();
  m_url = TQString::null;
  disk() -> commit();
}

void KPlayerDiskNode::updateTracks (void)
{
  if ( ! mediaDisk() )
    return;
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerDiskNode::updateTracks\n";
  kdDebugTime() << " Tracks " << disk() -> tracks() << "\n";
#endif
  if ( int (nodes().count()) != disk() -> tracks() )
  {
    KPlayerContainerNode::removed (nodes());
    TQString key (disk() -> type() == "Video CD" ? "MSF" : "Length");
    TQStringList tracklist;
    for ( int track = 1; track <= disk() -> tracks(); ++ track )
    {
      tracklist.append (TQString::number (track));
      if ( track <= int (m_track_lengths.count()) )
      {
        KURL url (disk() -> url());
        url.addPath (TQString::number (track));
        KPlayerTrackProperties* media = KPlayerMedia::trackProperties (url);
        media -> setupInfo();
        if ( ! media -> has (key) )
        {
          media -> setFloat (key, m_track_lengths [track - 1]);
          media -> commit();
        }
        KPlayerMedia::release (media);
      }
    }
    addedLeaves (tracklist);
  }
}

void KPlayerDiskNode::statResult (TDEIO::Job* job)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerDiskNode::statResult\n";
#endif
  if ( job -> error() )
  {
#ifdef DEBUG_KPLAYER_NODE
    kdDebugTime() << " Error  " << job -> error() << " " << job -> errorString() << "\n";
#endif
  }
  else
  {
    KFileItem item (((TDEIO::StatJob*) job) -> statResult(), "media:/" + url().fileName());
    if ( ! itemLocalPath (item).isEmpty() )
      parent() -> refreshItem (&item);
  }
  if ( dataDisk() )
  {
    m_url = TQString::null;
    disk() -> commit();
  }
  else
    autodetect();
}

void KPlayerDiskNode::receivedCddbOutput (KPlayerLineOutputProcess*, char* str, int)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << " <<<<<< " << str << "\n";
#endif
  if ( ! disk() )
    return;
  if ( re_track_length.search (str) >= 0 )
    m_cddb_id += re_track_length.cap(2);
  else if ( m_cddb_id == m_disk_id )
  {
    TQString line (TQString::fromLocal8Bit (str));
    if ( line.startsWith ("DTITLE=") )
    {
      line.remove (0, 7);
      m_artist = line.section ('/', 0, 0).simplifyWhiteSpace();
      m_album = line.section ('/', 1).simplifyWhiteSpace();
      if ( ! m_artist.isEmpty() || ! m_album.isEmpty() )
      {
        disk() -> setName (m_album.isEmpty() ? m_artist : m_artist.isEmpty() ? m_album : m_album + " - " + m_artist);
        disk() -> commit();
      }
    }
    else if ( line.startsWith ("DYEAR=") )
    {
      line.remove (0, 6);
      m_year = line.toInt();
      if ( m_year > 10 && m_year < 100 )
        m_year += 1900;
    }
    else if ( line.startsWith ("DGENRE=") )
    {
      line.remove (0, 7);
      m_genre = line.simplifyWhiteSpace();
    }
    else if ( line.startsWith ("TTITLE") )
    {
      line.remove (0, 6);
      bool ok;
      int track = line.section ('=', 0, 0).toInt (&ok) + 1;
      if ( ok )
      {
        KURL url (disk() -> url());
        url.addPath (TQString::number (track));
        KPlayerTrackProperties* media = KPlayerMedia::trackProperties (url);
        TQString title (line.section ('=', 1).simplifyWhiteSpace());
        if ( ! title.isEmpty() )
          media -> setName (title);
        if ( ! m_artist.isEmpty() )
          media -> setString ("Artist", m_artist);
        if ( ! m_album.isEmpty() )
          media -> setString ("Album", m_album);
        if ( m_year )
          media -> setString ("Year", TQString::number (m_year));
        if ( ! m_genre.isEmpty() )
          media -> setString ("Genre", m_genre);
        media -> commit();
        KPlayerMedia::release (media);
      }
    }
  }
}

void KPlayerDiskNode::cddbProcessExited (TDEProcess* process)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerDiskNode::cddbProcessExited\n";
#endif
  delete process;
}

KPlayerTunerNode::~KPlayerTunerNode()
{
}

void KPlayerTunerNode::setupSource (void)
{
  m_channel_list = media() -> channelList();
  m_source = new KPlayerTunerSource (this);
}

KPlayerNode* KPlayerTunerNode::createLeaf (const TQString& id)
{
  KPlayerChannelNode* node = new KPlayerChannelNode;
  node -> setup (this, id);
  return node;
}

void KPlayerTunerNode::updated (void)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerTunerNode::updated\n";
#endif
  if ( m_channel_list != media() -> channelList() )
  {
    m_channel_list = media() -> channelList();
    refreshNodes();
  }
}

KPlayerTVNode::~KPlayerTVNode()
{
}

void KPlayerTVNode::setupMedia (void)
{
  m_media = KPlayerMedia::tvProperties (metaurl());
  if ( ! media() -> hasType() )
    media() -> setType (parent() -> deviceType (id()));
  media() -> setDefaultName (parent() -> deviceName (id()));
  connect (media(), SIGNAL (updated()), SLOT (updated()));
}

KPlayerDVBNode::~KPlayerDVBNode()
{
}

void KPlayerDVBNode::setupMedia (void)
{
  m_media = KPlayerMedia::dvbProperties (metaurl());
  if ( ! media() -> hasType() )
    media() -> setType (parent() -> deviceType (id()));
  media() -> setDefaultName (parent() -> deviceName (id()));
  connect (media(), SIGNAL (updated()), SLOT (updated()));
}

#if 0
KPlayerSearchesNode::~KPlayerSearchesNode()
{
}

KPlayerContainerNode* KPlayerSearchesNode::createBranch (const TQString& id, KPlayerContainerNode* origin)
{
  KPlayerContainerNode* node = new KPlayerSearchNode;
  node -> setup (this, id, origin);
  return node;
}

bool KPlayerSearchesNode::canRename (void) const
{
  return false;
}

KPlayerSearchNode::~KPlayerSearchNode()
{
}

void KPlayerSearchNode::setupSource (void)
{
  m_source = new KPlayerSearchSource (this);
}

KPlayerNode* KPlayerSearchNode::createLeaf (const TQString& id)
{
  KPlayerNode* node = new KPlayerSearchItemNode;
  node -> setup (this, id);
  return node;
}

bool KPlayerSearchNode::allowsCustomOrder (void) const
{
  return false;
}
#endif

KPlayerNodeList::~KPlayerNodeList()
{
}

int KPlayerNodeList::compareItems (TQPtrCollection::Item item1, TQPtrCollection::Item item2)
{
  return ((KPlayerNode*) item1) -> compare ((KPlayerNode*) item2);
}

void KPlayerNodeList::releaseAll (void) const
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerNodeList::releaseAll\n";
#endif
  KPlayerNodeListIterator iterator (*this);
  while ( KPlayerNode* node = iterator.current() )
  {
    node -> release();
    ++ iterator;
  }
}

KPlayerNodeList KPlayerNodeList::fromUrlList (const KURL::List& urls)
{
#ifdef DEBUG_KPLAYER_NODE
  kdDebugTime() << "KPlayerNodeList::fromUrlList\n";
#endif
  KPlayerNodeList list;
  KURL::List::ConstIterator iterator (urls.begin());
  while ( iterator != urls.end() )
  {
    KURL url (*iterator);
    if ( url.path().isEmpty() && url.host().isEmpty() && url.protocol() == "file" )
      continue;
#ifdef DEBUG_KPLAYER_NODE
    kdDebugTime() << " URL    " << url.url() << "\n";
    kdDebugTime() << " Path   " << url.path() << "\n";
#endif
    if ( url.protocol() == "rtspt" || url.protocol() == "rtspu" )
      url.setProtocol ("rtsp");
    bool group = false, media = url.protocol() == "media";
    KPlayerNode* node = 0;
    if ( media || url.protocol() == "system" )
    {
      if ( media || url.url().startsWith ("system:/media/") )
        node = KPlayerNode::root() -> getNodeByUrl ("kplayer:/devices/dev" + (media ? url.path() : url.path().mid(6)));
      if ( ! node )
      {
        TDEIO::UDSEntry entry;
        if ( TDEIO::NetAccess::stat (url, entry, 0) )
        {
          KFileItem item (entry, url);
#ifdef DEBUG_KPLAYER_NODE
          kdDebugTime() << " Type   " << item.mimetype() << "\n";
#endif
          TQString path (itemLocalPath (item));
          if ( ! path.isEmpty() )
          {
            url = KURL::fromPathOrURL (path);
#ifdef DEBUG_KPLAYER_NODE
            kdDebugTime() << " Local  " << path << "\n";
#endif
          }
        }
#ifdef DEBUG_KPLAYER_NODE
        else
          kdDebugTime() << " Error  " << TDEIO::NetAccess::lastErrorString() << "\n";
#endif
      }
    }
    if ( url.isLocalFile() )
    {
      TQFileInfo info (url.path());
      group = info.isDir();
      if ( group )
        node = KPlayerNode::root() -> getNodeByUrl (url);
    }
    if ( node )
      node -> reference();
    else
      node = KPlayerNode::root() -> temporaryNode() -> temporaryItem (url.url());
    if ( node )
      list.append (node);
    ++ iterator;
  }
  return list;
}

KPlayerNodeListByName::~KPlayerNodeListByName()
{
}

int KPlayerNodeListByName::compareItems (TQPtrCollection::Item item1, TQPtrCollection::Item item2)
{
  return ((KPlayerNode*) item1) -> compareByName ((KPlayerNode*) item2);
}

KPlayerPlaylistNodeList::~KPlayerPlaylistNodeList()
{
}

int KPlayerPlaylistNodeList::compareItems (TQPtrCollection::Item item1, TQPtrCollection::Item item2)
{
  KPlayerNode* node1 = (KPlayerNode*) item1;
  KPlayerNode* node2 = (KPlayerNode*) item2;
  while ( node1 -> parent() )
  {
    KPlayerNode* node = node2;
    while ( node -> parent() )
    {
      if ( node1 == node -> parent() )
        return -1;
      if ( node == node1 -> parent() )
        return 1;
      if ( node1 -> parent() == node -> parent() )
        return node1 -> compare (node);
      node = node -> parent();
    }
    node1 = node1 -> parent();
  }
  return 0;
}