/**
 * Copyright (C) 2002-2003 by Koos Vriezen <koos.vriezen@gmail.com>
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Library General Public
 *  License version 2 as published by the Free Software Foundation.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Library General Public License for more details.
 *
 *  You should have received a copy of the GNU Library General Public License
 *  along with this library; see the file COPYING.LIB.  If not, write to
 *  the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor,
 *  Boston, MA 02110-1301, USA.
 **/

#ifdef KDE_USE_FINAL
#undef Always
#endif

#include <config.h>

#include <math.h>

#include <tqapplication.h>
#include <tqcstring.h>
#include <tqcursor.h>
#include <tqtimer.h>
#include <tqpair.h>
#include <tqpushbutton.h>
#include <tqpopupmenu.h>
#include <tqslider.h>
#include <tqfile.h>
#include <tqregexp.h>
#include <tqtextstream.h>

#include <tdemessagebox.h>
#include <tdeaboutdata.h>
#include <kdebug.h>
#include <kbookmarkmenu.h>
#include <kbookmarkmanager.h>
#include <tdeconfig.h>
#include <ksimpleconfig.h>
#include <tdeaction.h>
#include <kprocess.h>
#include <kstandarddirs.h>
#include <kmimetype.h>
#include <kprotocolinfo.h>
#include <tdeapplication.h>
#include <kstaticdeleter.h>
#include <tdeio/job.h>
#include <tdeio/jobclasses.h>

#include "kmplayerpartbase.h"
#include "kmplayerview.h"
#include "playlistview.h"
#include "viewarea.h"
#include "kmplayercontrolpanel.h"
#include "kmplayerconfig.h"
#include "kmplayerprocess.h"
#include "kmplayer_smil.h"

namespace KMPlayer {
    
class KMPLAYER_NO_EXPORT BookmarkOwner : public KBookmarkOwner {
public:
    BookmarkOwner (PartBase *);
    KDE_NO_CDTOR_EXPORT virtual ~BookmarkOwner () {}
    void openBookmarkURL(const TQString& _url);
    TQString currentTitle() const;
    TQString currentURL() const;
private:
    PartBase * m_player;
};

class KMPLAYER_NO_EXPORT BookmarkManager : public KBookmarkManager {
public:
    BookmarkManager (const TQString &);
};

} // namespace

using namespace KMPlayer;

KDE_NO_CDTOR_EXPORT BookmarkOwner::BookmarkOwner (PartBase * player)
    : m_player (player) {}

TDE_NO_EXPORT void BookmarkOwner::openBookmarkURL (const TQString & url) {
    m_player->openURL (KURL (url));
}

TDE_NO_EXPORT TQString BookmarkOwner::currentTitle () const {
    return m_player->source ()->prettyName ();
}

TDE_NO_EXPORT TQString BookmarkOwner::currentURL () const {
    return m_player->source ()->url ().url ();
}

inline BookmarkManager::BookmarkManager(const TQString & bmfile)
  : KBookmarkManager (bmfile, false) {
}

//-----------------------------------------------------------------------------

PartBase::PartBase (TQWidget * wparent, const char *wname,
                    TQObject * parent, const char *name, TDEConfig * config)
 : KMediaPlayer::Player (wparent, wname ? wname : "kde_kmplayer_view", parent, name ? name : "kde_kmplayer_part"),
   m_config (config),
   m_view (new View (wparent, wname ? wname : "kde_kmplayer_view")),
   m_settings (new Settings (this, config)),
   m_recorder (0L),
   m_source (0L),
   m_bookmark_menu (0L),
   m_record_timer (0),
   m_update_tree_timer (0),
   m_noresize (false),
   m_auto_controls (true),
   m_bPosSliderPressed (false),
   m_in_update_tree (false)
{
    MPlayer *mplayer = new MPlayer (this, m_settings);
    m_players ["mplayer"] = mplayer;
    m_process = mplayer;
    Xine * xine = new Xine (this, m_settings);
    m_players ["xine"] = xine;
    m_players ["gstreamer"] = new GStreamer (this, m_settings);
    m_recorders ["mencoder"] = new MEncoder (this, m_settings);
    m_recorders ["mplayerdumpstream"] = new MPlayerDumpstream(this, m_settings);
    m_recorders ["ffmpeg"] = new FFMpeg (this, m_settings);
    m_recorders ["xine"] = xine;
    m_sources ["urlsource"] = new URLSource (this);

    TQString bmfile = locate ("data", "kmplayer/bookmarks.xml");
    TQString localbmfile = locateLocal ("data", "kmplayer/bookmarks.xml");
    if (localbmfile != bmfile) {
        kdDebug () << "cp " << bmfile << " " << localbmfile << endl;
        TDEProcess p;
        p << "cp" << TQString(TQFile::encodeName (bmfile)) << TQString(TQFile::encodeName (localbmfile));
        p.start (TDEProcess::Block);
    }
    m_bookmark_manager = new BookmarkManager (localbmfile);
    m_bookmark_owner = new BookmarkOwner (this);
}

void PartBase::showConfigDialog () {
    m_settings->show ("URLPage");
}

void PartBase::showPlayListWindow () {
    // note, this is also the slot of application's view_playlist action, but
    // anyhow, actions don't work for the fullscreen out-of-the-box, so ...
    if (m_view->viewArea ()->isFullScreen ())
        fullScreen ();
    else if (m_view->viewArea ()->isMinimalMode ())
        ; //done by app: m_view->viewArea ()->minimalMode ();
    else
        m_view->toggleShowPlaylist ();
}

void PartBase::addBookMark (const TQString & t, const TQString & url) {
    KBookmarkGroup b = m_bookmark_manager->root ();
    b.addBookmark (m_bookmark_manager, t, KURL (url));
    m_bookmark_manager->emitChanged (b);
}

void PartBase::init (TDEActionCollection * action_collection) {
    KParts::Part::setWidget (m_view);
    m_view->init (action_collection);
#ifdef HAVE_NSPR
    m_players ["npp"] = new NpPlayer (this, m_settings, m_service);
#endif
    connect(m_settings, TQ_SIGNAL(configChanged()), this, TQ_SLOT(settingsChanged()));
    m_settings->readConfig ();
    m_settings->applyColorSetting (false);
    m_bookmark_menu = new KBookmarkMenu (m_bookmark_manager, m_bookmark_owner, m_view->controlPanel ()->bookmarkMenu (), action_collection, true, true);
    connect (m_view, TQ_SIGNAL (urlDropped (const KURL::List &)), this, TQ_SLOT (openURL (const KURL::List &)));
    connectPlaylist (m_view->playList ());
    connectInfoPanel (m_view->infoPanel ());
    new TDEAction (i18n ("Edit playlist &item"), 0, 0, m_view->playList (), TQ_SLOT (editCurrent ()), action_collection, "edit_playlist_item");
}

void PartBase::connectPanel (ControlPanel * panel) {
    panel->contrastSlider ()->setValue (m_settings->contrast);
    panel->brightnessSlider ()->setValue (m_settings->brightness);
    panel->hueSlider ()->setValue (m_settings->hue);
    panel->saturationSlider ()->setValue (m_settings->saturation);
    panel->volumeBar ()->setValue (m_settings->volume);
    connect (panel->button (ControlPanel::button_playlist), TQ_SIGNAL (clicked ()), this, TQ_SLOT (showPlayListWindow ()));
    connect (panel->button (ControlPanel::button_back), TQ_SIGNAL (clicked ()), this, TQ_SLOT (back ()));
    connect (panel->button (ControlPanel::button_play), TQ_SIGNAL (clicked ()), this, TQ_SLOT (play ()));
    connect (panel->button (ControlPanel::button_forward), TQ_SIGNAL (clicked ()), this, TQ_SLOT (forward ()));
    connect (panel->button (ControlPanel::button_pause), TQ_SIGNAL (clicked ()), this, TQ_SLOT (pause ()));
    connect (panel->button (ControlPanel::button_stop), TQ_SIGNAL (clicked ()), this, TQ_SLOT (stop ()));
    connect (panel->button (ControlPanel::button_record), TQ_SIGNAL (clicked()), this, TQ_SLOT (record()));
    connect (panel->volumeBar (), TQ_SIGNAL (volumeChanged (int)), this, TQ_SLOT (volumeChanged (int)));
    connect (panel->positionSlider (), TQ_SIGNAL (valueChanged (int)), this, TQ_SLOT (positionValueChanged (int)));
    connect (panel->positionSlider (), TQ_SIGNAL (sliderPressed()), this, TQ_SLOT (posSliderPressed()));
    connect (panel->positionSlider (), TQ_SIGNAL (sliderReleased()), this, TQ_SLOT (posSliderReleased()));
    connect (this, TQ_SIGNAL (positioned (int, int)), panel, TQ_SLOT (setPlayingProgress (int, int)));
    connect (this, TQ_SIGNAL (loading(int)), panel, TQ_SLOT(setLoadingProgress(int)));
    connect (panel->contrastSlider (), TQ_SIGNAL (valueChanged(int)), this, TQ_SLOT (contrastValueChanged(int)));
    connect (panel->brightnessSlider (), TQ_SIGNAL (valueChanged(int)), this, TQ_SLOT (brightnessValueChanged(int)));
    connect (panel->hueSlider (), TQ_SIGNAL (valueChanged(int)), this, TQ_SLOT (hueValueChanged(int)));
    connect (panel->saturationSlider (), TQ_SIGNAL (valueChanged(int)), this, TQ_SLOT (saturationValueChanged(int)));
    connect (this, TQ_SIGNAL (languagesUpdated(const TQStringList &, const TQStringList &)), panel, TQ_SLOT (setLanguages (const TQStringList &, const TQStringList &)));
    connect (panel->audioMenu (), TQ_SIGNAL (activated (int)), this, TQ_SLOT (audioSelected (int)));
    connect (panel->subtitleMenu (), TQ_SIGNAL (activated (int)), this, TQ_SLOT (subtitleSelected (int)));
    connect (this, TQ_SIGNAL (audioIsSelected (int)), panel, TQ_SLOT (selectAudioLanguage (int)));
    connect (this, TQ_SIGNAL (subtitleIsSelected (int)), panel, TQ_SLOT (selectSubtitle (int)));
    panel->popupMenu()->connectItem (ControlPanel::menu_fullscreen, this, TQ_SLOT (fullScreen ()));
    panel->popupMenu ()->connectItem (ControlPanel::menu_config,
                                       this, TQ_SLOT (showConfigDialog ()));
    panel->popupMenu ()->connectItem (ControlPanel::menu_video,
                                      m_view, TQ_SLOT(toggleVideoConsoleWindow()));
    panel->popupMenu ()->connectItem (ControlPanel::menu_playlist,
                                      m_view, TQ_SLOT (toggleShowPlaylist ()));
    panel->popupMenu ()->connectItem (ControlPanel::menu_minimal,
                                      this, TQ_SLOT (minimalMode ()));
    connect (this, TQ_SIGNAL (statusUpdated (const TQString &)),
             panel->view (), TQ_SLOT (setStatusMessage (const TQString &)));
    //connect (panel (), TQ_SIGNAL (clicked ()), m_settings, TQ_SLOT (show ()));
}

void PartBase::connectPlaylist (PlayListView * playlist) {
    connect (playlist, TQ_SIGNAL (addBookMark (const TQString &, const TQString &)),
             this, TQ_SLOT (addBookMark (const TQString &, const TQString &)));
    connect (playlist, TQ_SIGNAL (executed (TQListViewItem *)),
             this, TQ_SLOT (playListItemExecuted (TQListViewItem *)));
    connect (playlist, TQ_SIGNAL (clicked (TQListViewItem *)),
             this, TQ_SLOT (playListItemClicked (TQListViewItem *)));
    connect (this, TQ_SIGNAL (treeChanged (int, NodePtr, NodePtr, bool, bool)),
             playlist, TQ_SLOT (updateTree (int, NodePtr, NodePtr, bool, bool)));
    connect (this, TQ_SIGNAL (treeUpdated ()),
             playlist, TQ_SLOT (triggerUpdate ()));
}

void PartBase::connectInfoPanel (InfoWindow * infopanel) {
    connect (this, TQ_SIGNAL (infoUpdated (const TQString &)),
             infopanel->view (), TQ_SLOT (setInfoMessage (const TQString &)));
}

PartBase::~PartBase () {
    kdDebug() << "PartBase::~PartBase" << endl;
    m_view = (View*) 0;
    stop ();
    if (m_source)
        m_source->deactivate ();
    delete m_settings;
    delete m_bookmark_menu;
    delete m_bookmark_manager;
    delete m_bookmark_owner;
}

void PartBase::settingsChanged () {
    if (!m_view)
        return;
    if (m_settings->showcnfbutton)
        m_view->controlPanel()->button (ControlPanel::button_config)->show();
    else
        m_view->controlPanel()->button (ControlPanel::button_config)->hide();
    m_view->controlPanel()->enableRecordButtons (m_settings->showrecordbutton);
    if (m_settings->showplaylistbutton)
        m_view->controlPanel()->button (ControlPanel::button_playlist)->show();
    else
        m_view->controlPanel()->button (ControlPanel::button_playlist)->hide();
    if (!m_settings->showbroadcastbutton)
        m_view->controlPanel ()->broadcastButton ()->hide ();
    keepMovieAspect (m_settings->sizeratio);
    m_settings->applyColorSetting (true);
}

KMediaPlayer::View* PartBase::view () {
    return m_view;
}

extern const char * strGeneralGroup;

bool PartBase::setProcess (Mrl *mrl) {
    // determine backend, start with temp_backends
    TQString p = temp_backends [m_source->name()];
    bool remember_backend = p.isEmpty ();
    bool changed = false;
    if (p.isEmpty ()) {
        // next try to find mimetype match from kmplayerrc
        if (!mrl->mimetype.isEmpty ()) {
            m_config->setGroup (mrl->mimetype);
            p = m_config->readEntry ("player", "" );
            remember_backend = !(!p.isEmpty () &&
                    m_players.contains (p) &&
                    m_players [p]->supports (m_source->name ()));
        }
    }
    if (p.isEmpty ())
        // try source match from kmplayerrc
        p = m_settings->backends [m_source->name()];
    if (p.isEmpty ()) {
        // try source match from kmplayerrc by re-reading
        m_config->setGroup (strGeneralGroup);
        p = m_config->readEntry (m_source->name (), "");
    }
    if (p.isEmpty () ||
            !m_players.contains (p) ||
            !m_players [p]->supports (m_source->name ())) {
        // finally find first supported player
        p.truncate (0);
        if (!m_process || !m_process->supports (m_source->name ())) {
            ProcessMap::const_iterator i, e = m_players.end();
            for (i = m_players.begin(); i != e; ++i)
                if (i.data ()->supports (m_source->name ())) {
                    p = TQString (i.data ()->name ());
                    break;
                }
        } else
            p = TQString (m_process->name ());
    }
    if (!p.isEmpty ()) {
        if (!m_process || p != m_process->name ()) {
            setProcess (p.ascii ());
            updatePlayerMenu (m_view->controlPanel ());
            changed = true;
        }
        if (remember_backend)
            m_settings->backends [m_source->name()] = m_process->name ();
        else
            temp_backends.remove (m_source->name());
    }
    return changed;
}

void PartBase::setProcess (const char * name) {
    Process * process = name ? m_players [name] : 0L;
    if (m_process == process)
        return;
    if (!m_source)
        m_source = m_sources ["urlsource"];
    Process * old_process = m_process;
    m_process = process;
    if (old_process && old_process->state () > Process::NotRunning)
        old_process->quit ();
    if (!m_process)
        return;
    m_process->setSource (m_source);
    if (m_process->playing ()) {
        m_view->controlPanel ()->setPlaying (true);
        m_view->controlPanel ()->showPositionSlider (!!m_source->length ());
        m_view->controlPanel ()->enableSeekButtons (m_source->isSeekable ());
    }
    emit processChanged (name);
}

void PartBase::setRecorder (const char * name) {
    Process * recorder = name ? m_recorders [name] : 0L;
    if (m_recorder == recorder)
        return;
    if (m_recorder)
        m_recorder->quit ();
    m_recorder = recorder;
}

void PartBase::slotPlayerMenu (int id) {
    bool playing = m_process->playing ();
    const char * srcname = m_source->name ();
    TQPopupMenu * menu = m_view->controlPanel ()->playerMenu ();
    ProcessMap::const_iterator pi = m_players.begin(), e = m_players.end();
    unsigned i = 0;
    for (; pi != e && i < menu->count(); ++pi) {
        Process * proc = pi.data ();
        if (!proc->supports (srcname))
            continue;
        int menuid = menu->idAt (i);
        menu->setItemChecked (menuid, menuid == id);
        if (menuid == id) {
            if (proc->name () != TQString ("npp"))
                m_settings->backends [srcname] = proc->name ();
            temp_backends [srcname] = proc->name ();
            if (playing && strcmp (m_process->name (), proc->name ()))
                m_process->quit ();
            setProcess (proc->name ());
        }
        ++i;
    }
    if (playing)
        setSource (m_source); // re-activate
}

void PartBase::updatePlayerMenu (ControlPanel * panel) {
    if (!m_view || !m_process)
        return;
    TQPopupMenu * menu = panel->playerMenu ();
    menu->clear ();
    if (!m_source)
        return;
    const ProcessMap::const_iterator e = m_players.end();
    int id = 0; // if multiple parts, id's should be the same for all menu's
    for (ProcessMap::const_iterator i = m_players.begin(); i != e; ++i) {
        Process * p = i.data ();
        if (p->supports (m_source->name ())) {
            menu->insertItem (p->menuName (), this, TQ_SLOT (slotPlayerMenu (int)), 0, id++);
            if (i.data() == m_process)
                menu->setItemChecked (id-1, true);
        }
    }
}

void PartBase::connectSource (Source * old_source, Source * source) {
    if (old_source) {
        disconnect (old_source, TQ_SIGNAL(endOfPlayItems ()), this, TQ_SLOT(stop ()));
        disconnect (old_source, TQ_SIGNAL (dimensionsChanged ()),
                    this, TQ_SLOT (sourceHasChangedAspects ()));
        disconnect (old_source, TQ_SIGNAL (startPlaying ()),
                    this, TQ_SLOT (playingStarted ()));
        disconnect (old_source, TQ_SIGNAL (stopPlaying ()),
                    this, TQ_SLOT (playingStopped ()));
    }
    if (source) {
        connect (source, TQ_SIGNAL (endOfPlayItems ()), this, TQ_SLOT (stop ()));
        connect (source, TQ_SIGNAL (dimensionsChanged ()),
                this, TQ_SLOT (sourceHasChangedAspects ()));
        connect (source, TQ_SIGNAL (startPlaying()), this, TQ_SLOT(playingStarted()));
        connect (source, TQ_SIGNAL (stopPlaying ()), this, TQ_SLOT(playingStopped()));
    }
}

void PartBase::setSource (Source * _source) {
    Source * old_source = m_source;
    if (m_source) {
        m_source->deactivate ();
        stop ();
        if (m_view) {
            m_view->reset ();
            emit infoUpdated (TQString ());
        }
        disconnect (m_source, TQ_SIGNAL (startRecording ()),
                    this, TQ_SLOT (recordingStarted ()));
        disconnect (this, TQ_SIGNAL (audioIsSelected (int)),
                    m_source, TQ_SLOT (setAudioLang (int)));
        disconnect (this, TQ_SIGNAL (subtitleIsSelected (int)),
                    m_source, TQ_SLOT (setSubtitle (int)));
    }
    if (m_view) {
        if (m_auto_controls)
            m_view->controlPanel ()->setAutoControls (m_auto_controls);
        m_view->controlPanel ()->enableRecordButtons (m_settings->showrecordbutton);
        if (!m_settings->showcnfbutton)
            m_view->controlPanel()->button(ControlPanel::button_config)->hide();
        if (!m_settings->showplaylistbutton)
          m_view->controlPanel()->button(ControlPanel::button_playlist)->hide();
    }
    m_source = _source;
    connectSource (old_source, m_source);
    m_process->setSource (m_source);
    connect (m_source, TQ_SIGNAL(startRecording()), this,TQ_SLOT(recordingStarted()));
    connect (this, TQ_SIGNAL (audioIsSelected (int)),
             m_source, TQ_SLOT (setAudioLang (int)));
    connect (this, TQ_SIGNAL (subtitleIsSelected (int)),
             m_source, TQ_SLOT (setSubtitle (int)));
    m_source->init ();
    m_source->setIdentified (false);
    if (m_view && m_view->viewer ()) {
        updatePlayerMenu (m_view->controlPanel ());
        m_view->viewer ()->setAspect (0.0);
    }
    if (m_source) TQTimer::singleShot (0, m_source, TQ_SLOT (activate ()));
    updateTree (true, true);
    emit sourceChanged (old_source, m_source);
}

TDE_NO_EXPORT void PartBase::changeURL (const TQString & url) {
    emit urlChanged (url);
}

bool PartBase::isSeekable (void) const {
    return m_source ? m_source->isSeekable () : false;
}

bool PartBase::hasLength () const {
    return m_source ? m_source->hasLength () : false; 
}

unsigned long PartBase::length () const {
    return m_source ? m_source->length () : 0;
}

bool PartBase::openURL (const KURL & url) {
    kdDebug () << "PartBase::openURL " << url.url() << url.isValid () << endl;
    if (!m_view) return false;
    stop ();
    Source * src = (url.isEmpty () ? m_sources ["urlsource"] : (!url.protocol ().compare ("kmplayer") && m_sources.contains (url.host ()) ? m_sources [url.host ()] : m_sources ["urlsource"]));
    src->setSubURL (KURL ());
    src->setURL (url);
    setSource (src);
    return true;
}

bool PartBase::openURL (const KURL::List & urls) {
    if (urls.size () == 1) {
        openURL (urls[0]);
    } else {
        openURL (KURL ());
        NodePtr d = m_source->document ();
        if (d)
            for (unsigned int i = 0; i < urls.size (); i++)
                d->appendChild (new GenericURL (d, KURL::decode_string (urls [i].url ())));
    }
    return true;
}

bool PartBase::closeURL () {
    stop ();
    if (m_view) {
        m_view->viewer ()->setAspect (0.0);
        m_view->reset ();
    }
    return true;
}

bool PartBase::openFile () {
    return false;
}

void PartBase::keepMovieAspect (bool b) {
    if (m_view) {
        m_view->setKeepSizeRatio (b);
        if (m_source)
            m_view->viewer ()->setAspect (b ? m_source->aspect () : 0.0);
    }
}

void PartBase::recordingStarted () {
    if (m_settings->replayoption == Settings::ReplayAfter)
        m_record_timer = startTimer (1000 * m_settings->replaytime);
}

void PartBase::recordingStopped () {
    killTimer (m_record_timer);
    m_record_timer = 0;
    Recorder * rec = dynamic_cast <Recorder*> (m_recorder);
    if (rec) {
        if (m_settings->replayoption == Settings::ReplayFinished ||
             (m_settings->replayoption == Settings::ReplayAfter && !playing ()))
            openURL (rec->recordURL ());
        rec->setURL (KURL ());
    }
    setRecorder ("mencoder"); //FIXME see PartBase::record() checking playing()
}

void PartBase::timerEvent (TQTimerEvent * e) {
    if (e->timerId () == m_record_timer) {
        kdDebug () << "record timer event" << (m_recorder->playing () && !playing ()) << endl;
        m_record_timer = 0;
        if (m_recorder->playing () && !playing ()) {
            Recorder * rec = dynamic_cast <Recorder*> (m_recorder);
            if (rec) {
                openURL (rec->recordURL ());
                rec->setURL (KURL ());
            }
        }
    } else if (e->timerId () == m_update_tree_timer) {
        m_update_tree_timer = 0;
        updateTree (m_update_tree_full, true);
    }
    killTimer (e->timerId ());
}

void PartBase::playingStarted () {
    //m_view->viewer ()->setAspect (m_source->aspect ());
    if (m_view) {
        m_view->controlPanel ()->setPlaying (true);
        m_view->controlPanel ()->showPositionSlider (!!m_source->length ());
        m_view->controlPanel ()->enableSeekButtons (m_source->isSeekable ());
        if (m_settings->autoadjustvolume && m_process)
           m_process->volume(m_view->controlPanel()->volumeBar()->value(),true);
    }
    emit loading (100);
}

void PartBase::playingStopped () {
    kdDebug () << "playingStopped " << this << endl;
    if (m_view) {
        m_view->controlPanel ()->setPlaying (false);
        m_view->reset ();
    }
    m_bPosSliderPressed = false;
}

void PartBase::setPosition (int position, int length) {
    if (m_view && !m_bPosSliderPressed)
        emit positioned (position, length);
}

void PartBase::setLoaded (int percentage) {
    emit loading (percentage);
}

unsigned long PartBase::position () const {
    return m_source ? 100 * m_source->position () : 0;
}

void PartBase::pause () {
    NodePtr doc = m_source ? m_source->document () : 0L;
    if (doc) {
        if (doc->state == Node::state_deferred)
            doc->undefer ();
        else
            doc->defer ();
    }
}

void PartBase::back () {
    m_source->backward ();
}

void PartBase::forward () {
    m_source->forward ();
}

TDE_NO_EXPORT void PartBase::playListItemClicked (TQListViewItem * item) {
    if (!item)
        return;
    PlayListItem * vi = static_cast <PlayListItem *> (item);
    RootPlayListItem * ri = vi->playListView ()->rootItem (item);
    if (ri == item && vi->node) {
        TQString src = ri->source;
        //kdDebug() << "playListItemClicked " << src << " " << vi->node->nodeName() << endl;
        Source * source = src.isEmpty() ? m_source : m_sources[src.ascii()];
        if (vi->node->isPlayable ()) {
            source->jump (vi->node); //may become !isPlayable by lazy loading
            if (!vi->node->isPlayable ())
                emit treeChanged (ri->id, vi->node, 0, false, true);
        } else if (vi->firstChild ())
            vi->listView ()->setOpen (vi, !vi->isOpen ());
    } else if (!vi->node && !vi->m_attr)
        updateTree (); // items already deleted
}

TDE_NO_EXPORT void PartBase::playListItemExecuted (TQListViewItem * item) {
    if (m_in_update_tree) return;
    if (m_view->editMode ()) return;
    PlayListItem * vi = static_cast <PlayListItem *> (item);
    RootPlayListItem * ri = vi->playListView ()->rootItem (item);
    if (ri == item)
        return; // both null or handled by playListItemClicked
    if (vi->node) {
        TQString src = ri->source;
        //kdDebug() << "playListItemExecuted " << src << " " << vi->node->nodeName() << endl;
        Source * source = src.isEmpty() ? m_source : m_sources[src.ascii()];
        if (vi->node->isPlayable ()) {
            source->jump (vi->node); //may become !isPlayable by lazy loading
            if (!vi->node->isPlayable ())
                emit treeChanged (ri->id, vi->node, 0, false, true);
        } else if (vi->firstChild ())
            vi->listView ()->setOpen (vi, !vi->isOpen ());
    } else if (vi->m_attr) {
        if (vi->m_attr->name () == StringPool::attr_src ||
                vi->m_attr->name () == StringPool::attr_href ||
                vi->m_attr->name () == StringPool::attr_url ||
                vi->m_attr->name () == StringPool::attr_value ||
                vi->m_attr->name () == "data") {
            TQString src (vi->m_attr->value ());
            if (!src.isEmpty ()) {
                PlayListItem * pi = static_cast <PlayListItem*>(item->parent());
                if (pi) {
                    for (NodePtr e = pi->node; e; e = e->parentNode ()) {
                        Mrl * mrl = e->mrl ();
                        if (mrl)
                            src = KURL (mrl->absolutePath (), src).url ();
                    }
                    KURL url (src);
                    if (url.isValid ())
                        openURL (url);
                }
            }
        }
    } else
        emit treeChanged (ri->id, ri->node, 0L, false, false);
    if (m_view)
        m_view->viewArea ()->setFocus ();
}

void PartBase::updateTree (bool full, bool force) {
    if (force) {
        m_in_update_tree = true;
        if (m_update_tree_full) {
            if (m_source)
                emit treeChanged (0, m_source->root (), m_source->current (), true, false);
        } else
            emit treeUpdated ();
        m_in_update_tree = false;
        if (m_update_tree_timer) {
            killTimer (m_update_tree_timer);
            m_update_tree_timer = 0;
        }
    } else if (!m_update_tree_timer) {
        m_update_tree_timer = startTimer (100);
        m_update_tree_full = full;
    } else
        m_update_tree_full |= full;
}

void PartBase::updateInfo (const TQString & msg) {
    emit infoUpdated (msg);
}

void PartBase::updateStatus (const TQString & msg) {
    emit statusUpdated (msg);
}

void PartBase::setLanguages (const TQStringList & al, const TQStringList & sl) {
    emit languagesUpdated (al, sl);
}

TDE_NO_EXPORT void PartBase::audioSelected (int id) {
    emit audioIsSelected (id);
}

TDE_NO_EXPORT void PartBase::subtitleSelected (int id) {
    emit subtitleIsSelected (id);
}

void PartBase::record () {
    if (m_view) m_view->setCursor (TQCursor (TQt::WaitCursor));
    if (m_recorder->playing ()) {
        m_recorder->stop ();
    } else {
        m_settings->show  ("RecordPage");
        m_view->controlPanel ()->setRecording (false);
    }
    if (m_view) m_view->setCursor (TQCursor (TQt::ArrowCursor));
}

void PartBase::play () {
    if (!m_process || !m_view) return;
    TQPushButton * pb = ::tqt_cast <TQPushButton *> (sender ());
    if (pb && !pb->isOn ()) {
        stop ();
        return;
    }
    if (m_update_tree_timer) {
        killTimer (m_update_tree_timer);
        m_update_tree_timer = 0;
    }
    if (m_process->state () == Process::NotRunning) {
        PlayListItem * lvi = m_view->playList ()->currentPlayListItem ();
        if (lvi) { // make sure it's in the first tree
            TQListViewItem * pitem = lvi;
            while (pitem->parent())
                pitem = pitem->parent();
            if (pitem != m_view->playList ()->firstChild ())
                lvi = 0L;
        }
        if (!lvi)
            lvi = static_cast<PlayListItem*>(m_view->playList()->firstChild());
        if (lvi)
            for (NodePtr n = lvi->node; n; n = n->parentNode ()) {
                if (n->isPlayable ()) {
                    m_source->setCurrent (n);
                    break;
                }
            }
        m_process->ready (m_view->viewer ());
    } else if (m_process->state () == Process::Ready) {
        m_source->playCurrent ();
    } else
        m_process->play (m_source, m_source->current ());
}

bool PartBase::playing () const {
    return m_process && m_process->state () > Process::Ready;
}

void PartBase::stop () {
    TQPushButton * b = m_view ? m_view->controlPanel ()->button (ControlPanel::button_stop) : 0L;
    if (b) {
        if (!b->isOn ())
            b->toggle ();
        m_view->setCursor (TQCursor (TQt::WaitCursor));
    }
    if (m_process)
        m_process->quit ();
    if (m_source)
        m_source->reset ();
    if (m_view) {
        m_view->setCursor (TQCursor (TQt::ArrowCursor));
        if (b->isOn ())
            b->toggle ();
        m_view->controlPanel ()->setPlaying (false);
        setLoaded (100);
    }
}

void PartBase::seek (unsigned long msec) {
    if (m_process)
        m_process->seek (msec/100, true);
}

void PartBase::adjustVolume (int incdec) {
    m_process->volume (incdec, false);
}

void PartBase::increaseVolume () {
    if (m_view)
        m_view->controlPanel ()->volumeBar ()->setValue (m_view->controlPanel ()->volumeBar ()->value () + 2);
}

void PartBase::decreaseVolume () {
    if (m_view)
        m_view->controlPanel ()->volumeBar ()->setValue (m_view->controlPanel ()->volumeBar ()->value () - 2);
}

TDE_NO_EXPORT void PartBase::posSliderPressed () {
    m_bPosSliderPressed=true;
}

TDE_NO_EXPORT void PartBase::posSliderReleased () {
    m_bPosSliderPressed=false;
    const TQSlider * posSlider = ::tqt_cast<const TQSlider *> (sender ());
    if (posSlider)
        m_process->seek (posSlider->value(), true);
}

void PartBase::volumeChanged (int val) {
    if (m_process) {
        m_settings->volume = val;
        m_process->volume (val, true);
    }
}

TDE_NO_EXPORT void PartBase::contrastValueChanged (int val) {
    m_settings->contrast = val;
    m_process->contrast (val, true);
}

TDE_NO_EXPORT void PartBase::brightnessValueChanged (int val) {
    m_settings->brightness = val;
    m_process->brightness (val, true);
}

TDE_NO_EXPORT void PartBase::hueValueChanged (int val) {
    m_settings->hue = val;
    m_process->hue (val, true);
}

TDE_NO_EXPORT void PartBase::saturationValueChanged (int val) {
    m_settings->saturation = val;
    m_process->saturation (val, true);
}

TDE_NO_EXPORT void PartBase::sourceHasChangedAspects () {
    if (m_view && m_source) {
      //kdDebug () << "sourceHasChangedAspects " << m_source->aspect () << endl;
        m_view->viewer ()->setAspect (m_source->aspect ());
        m_view->updateLayout ();
    }
    emit sourceDimensionChanged ();
}

TDE_NO_EXPORT void PartBase::positionValueChanged (int pos) {
    TQSlider * slider = ::tqt_cast <TQSlider *> (sender ());
    if (slider && slider->isEnabled ())
        m_process->seek (pos, true);
}

TDE_NO_EXPORT void PartBase::fullScreen () {
    if (m_view)
        m_view->fullScreen ();
}

void PartBase::toggleFullScreen () {
    m_view->fullScreen ();
}

TDE_NO_EXPORT void PartBase::minimalMode () {
    emit toggleMinimalMode ();
}

bool PartBase::isPlaying () {
    return playing ();
}

bool PartBase::isPaused () {
    NodePtr doc = m_source ? m_source->document () : 0L;
    return doc && doc->state == Node::state_deferred;
}

TDEAboutData* PartBase::createAboutData () {
    KMessageBox::error(0L, "createAboutData", "KMPlayer");
    return 0;
}

//-----------------------------------------------------------------------------

Source::Source (const TQString & name, PartBase * player, const char * n)
 : TQObject (player, n),
   m_name (name), m_player (player), m_identified (false), m_auto_play (true),
   m_frequency (0), m_xvport (0), m_xvencoding (-1), m_doc_timer (0) {
    init ();
}

Source::~Source () {
    if (m_document)
        m_document->document ()->dispose ();
    m_document = 0L;
    Q_ASSERT (m_current.ptr () == 0L);
}

void Source::init () {
    //setDimensions (320, 240);
    m_width = 0;
    m_height = 0;
    m_aspect = 0.0;
    m_length = 0;
    m_position = 0;
    setLength (m_document, 0);
    m_recordcmd.truncate (0);
}

TDE_NO_EXPORT void Source::setLanguages (const TQStringList & alang, const TQStringList & slang) {
    m_player->setLanguages (alang, slang);
}

void Source::setDimensions (NodePtr node, int w, int h) {
    Mrl * mrl = node ? node->mrl () : 0L;
    if (mrl && mrl->view_mode == Mrl::WindowMode) {
        mrl->width = w;
        mrl->height = h;
        float a = h > 0 ? 1.0 * w / h : 0.0;
        mrl->aspect = a;
        if (m_player->view ()) {
            static_cast <View *> (m_player->view())->viewer()->setAspect(a);
            static_cast <View *> (m_player->view ())->updateLayout ();
        }
    } else if (m_aspect < 0.001 || m_width != w || m_height != h) {
        bool ev = (w > 0 && h > 0) ||
            (h == 0 && m_height > 0) ||
            (w == 0 && m_width > 0);
        m_width = w;
        m_height = h;
        if (m_aspect < 0.001)
            setAspect (node, h > 0 ? 1.0 * w / h : 0.0);
        //kdDebug () << "setDimensions " << w << "x" << h << " a:" << m_aspect << endl;
        if (ev)
            emit dimensionsChanged ();
    }
}

void Source::setAspect (NodePtr node, float a) {
    //kdDebug () << "setAspect " << a << endl;
    Mrl * mrl = node ? node->mrl () : 0L;
    bool changed = false;
    if (mrl) {
        if (mrl->view_mode == Mrl::WindowMode)
            changed |= (fabs (mrl->aspect - a) > 0.001);
        mrl->aspect = a;
    }
    if (!mrl || mrl->view_mode == Mrl::SingleMode) {
        changed |= (fabs (m_aspect - a) > 0.001);
        m_aspect = a;
    }
    if (changed)
        emit dimensionsChanged ();
}

void Source::setLength (NodePtr, int len) {
    m_length = len;
    m_player->setPosition (m_position, m_length);
}

TDE_NO_EXPORT void Source::setPosition (int pos) {
    m_position = pos;
    m_player->setPosition (pos, m_length);
}

TDE_NO_EXPORT void Source::setLoading (int percentage) {
    m_player->setLoaded (percentage);
}

/*
static void printTree (NodePtr root, TQString off=TQString()) {
    if (!root) {
        kdDebug() << off << "[null]" << endl;
        return;
    }
    kdDebug() << off << root->nodeName() << " " << (Element*)root << (root->isPlayable() ? root->mrl ()->src : TQString ("-")) << endl;
    off += TQString ("  ");
    for (NodePtr e = root->firstChild(); e; e = e->nextSibling())
        printTree(e, off);
}*/

void Source::setURL (const KURL & url) {
    m_url = url;
    m_back_request = 0L;
    if (m_document && !m_document->hasChildNodes () &&
            (m_document->mrl()->src.isEmpty () ||
             m_document->mrl()->src == url.url ()))
        // special case, mime is set first by plugin FIXME v
        m_document->mrl()->src = url.url ();
    else {
        if (m_document)
            m_document->document ()->dispose ();
        m_document = new Document (url.url (), this);
    }
    if (m_player->process () && m_player->source () == this)
        m_player->updateTree ();
    //kdDebug() << name() << " setURL " << url << endl;
    m_current = m_document;
}

void Source::setTitle (const TQString & title) {
    emit titleChanged (title);
}

TDE_NO_EXPORT void Source::setAudioLang (int id) {
    View * v = static_cast <View *> (m_player->view());
    if (v && m_player->process ())
        m_player->process ()->setAudioLang (id, v->controlPanel ()->audioMenu ()->text (id));
}

TDE_NO_EXPORT void Source::setSubtitle (int id) {
    View * v = static_cast <View *> (m_player->view());
    if (v && m_player->process ())
        m_player->process ()->setSubtitle (id, v->controlPanel ()->subtitleMenu ()->text (id));
}

void Source::reset () {
    if (m_document) {
        //kdDebug() << "Source::first" << endl;
        m_current = NodePtr ();
        m_document->reset ();
        m_player->updateTree ();
    }
    init ();
}

TQString Source::currentMrl () {
    Mrl * mrl = m_current ? m_current->mrl () : 0L;
    kdDebug() << "Source::currentMrl " << (m_current ? m_current->nodeName():"") << " src:" << (mrl ? mrl->absolutePath ()  : TQString ()) << endl;
    return mrl ? mrl->absolutePath () : TQString ();
}

void Source::playCurrent () {
    TQString url = currentMrl ();
    m_player->changeURL (url);
    m_width = m_height = 0;
    m_aspect = 0.0;
    if (m_player->view ())
        static_cast <View *> (m_player->view ())->playingStop ();//show controls
    if (m_document && !m_document->active ()) {
        if (!m_current)
            m_document->activate ();
        else { // ugly code duplicate w/ back_request
            for (NodePtr p = m_current->parentNode(); p; p = p->parentNode())
                p->state = Element::state_activated;
            m_current->activate ();
        }
    } else if (!m_current) {
        emit endOfPlayItems ();
    } else if (m_current->state == Element::state_deferred) {
     //   m_current->undefer ();
    } else if (m_player->process ()->state () == Process::NotRunning) {
        m_player->process ()->ready (static_cast <View *> (m_player->view ())->viewer ());
    } else if (m_player->process ()) {
        Mrl * mrl = m_back_request ? m_back_request->mrl () : m_current->mrl ();
        if (mrl->view_mode == Mrl::SingleMode) {
            // don't reset the dimensions if we have any
            m_width = mrl->width;
            m_height = mrl->height;
            m_aspect = mrl->aspect;
        }
        m_back_request = 0L;
        m_player->process ()->play (this, mrl->linkNode ());
    }
    //kdDebug () << "Source::playCurrent " << (m_current ? m_current->nodeName():" doc act:") <<  (m_document && !m_document->active ()) << " cur:" << (!m_current)  << " cur act:" << (m_current && !m_current->active ()) <<  endl;
    m_player->updateTree ();
    emit dimensionsChanged ();
}

static NodePtr findDepthFirst (NodePtr elm) {
    if (!elm)
        return NodePtr ();
    NodePtr tmp = elm;
    for ( ; tmp; tmp = tmp->nextSibling ()) {
        if (tmp->isPlayable ())
            return tmp;
        NodePtr tmp2 = findDepthFirst (tmp->firstChild ());
        if (tmp2)
            return tmp2;
    }
    return NodePtr ();
}

bool Source::requestPlayURL (NodePtr mrl) {
    //kdDebug() << "Source::requestPlayURL " << mrl->mrl ()->src << endl;
    if (m_player->process ()->state () > Process::Ready) {
        if (m_player->process ()->mrl () == mrl->mrl ()->linkNode ())
            return true;
        m_back_request = mrl; // still playing, schedule it
        m_player->process ()->stop ();
    } else {
        if (mrl->mrl ()->view_mode == Mrl::SingleMode)
            m_current = mrl;
        else
            m_back_request = mrl;
        m_player->updateTree ();
        TQTimer::singleShot (0, this, TQ_SLOT (playCurrent ()));
    }
    m_player->setProcess (mrl->mrl ());
    return true;
}

bool Source::resolveURL (NodePtr) {
    return true;
}

void Source::setTimeout (int ms) {
    //kdDebug () << "Source::setTimeout " << ms << endl;
    if (m_doc_timer)
        killTimer (m_doc_timer);
    m_doc_timer = ms > -1 ? startTimer (ms) : 0;
}

void Source::timerEvent (TQTimerEvent * e) {
    if (e->timerId () == m_doc_timer && m_document && m_document->active ())
        m_document->document ()->timer (); // will call setTimeout()
    else
        killTimer (e->timerId ());
}

bool Source::setCurrent (NodePtr mrl) {
    m_current = mrl;
    return true;
}

void Source::stateElementChanged (Node * elm, Node::State os, Node::State ns) {
    //kdDebug() << "[01;31mSource::stateElementChanged[00m " << elm->nodeName () << " state:" << (int) elm->state << " cur isPlayable:" << (m_current && m_current->isPlayable ()) << " elm==linkNode:" << (m_current && elm == m_current->mrl ()->linkNode ()) << " p state:" << m_player->process ()->state () << endl;
    if (ns == Node::state_deactivated && elm == m_document && !m_back_request) {
        emit endOfPlayItems (); // played all items
    } else if ((ns == Node::state_deactivated || ns == Node::state_finished) &&
             m_player->process ()->mrl() &&
             elm == m_player->process ()->mrl ()->mrl ()->linkNode ()) {
        if (m_player->process ()->state () > Process::Ready)
            //a SMIL movies stopped by SMIL events rather than movie just ending
            m_player->process ()->stop ();
        if (m_player->view ()) // move away the video widget
            TQTimer::singleShot (0, m_player->view (), TQ_SLOT (updateLayout ()));
    } else if ((ns == Node::state_deferred ||
                (os == Node::state_deferred && ns > Node::state_deferred)) &&
            elm == m_document) {
        m_player->process ()->pause ();
    } else if (ns == Node::state_activated &&
            elm->isPlayable () &&
            elm->mrl ()->view_mode == Mrl::SingleMode) {
        Node *p = elm->parentNode();
        if (!p || !p->mrl () || p->mrl ()->view_mode == Mrl::SingleMode)
            // make sure we don't set current to nested document
            m_current = elm;
    }
    if (elm->expose ()) {
        if (ns == Node::state_activated || ns == Node::state_deactivated)
            m_player->updateTree ();
        else if (ns == Node::state_began || os == Node::state_began)
            m_player->updateTree (false);
    }
}

SurfacePtr Source::getSurface (NodePtr n) {
    if (m_player->view ())
        return static_cast <View*>(m_player->view())->viewArea()->getSurface(n);
    return 0L;
}

void Source::setInfoMessage (const TQString & msg) {
    m_player->updateInfo (msg);
}

void Source::bitRates (int & preferred, int & maximal) {
    preferred = 1024 * m_player->settings ()->prefbitrate;
    maximal= 1024 * m_player->settings ()->maxbitrate;
}

void Source::insertURL (NodePtr node, const TQString & mrl, const TQString & title) {
    if (!node || !node->mrl ()) // this should always be false
        return;
    TQString cur_url = node->mrl ()->absolutePath ();
    KURL url (cur_url, mrl);
    kdDebug() << "Source::insertURL " << KURL (cur_url) << " " << url << endl;
    if (!url.isValid ())
        kdError () << "try to append non-valid url" << endl;
    else if (KURL (cur_url) == url)
        kdError () << "try to append url to itself" << endl;
    else {
        int depth = 0; // cache this?
        for (NodePtr e = node; e->parentNode (); e = e->parentNode ())
            ++depth;
        if (depth < 40) {
            node->appendChild (new GenericURL (m_document, KURL::decode_string (url.url ()), title.isEmpty() ? KURL::decode_string (mrl) : title));
            m_player->updateTree ();
        } else
            kdError () << "insertURL exceeds depth limit" << endl;
    }
}

void Source::play () {
    m_player->updateTree ();
    TQTimer::singleShot (0, m_player, TQ_SLOT (play ()));
    //printTree (m_document);
}

void Source::backward () {
    if (m_document->hasChildNodes ()) {
        m_back_request = m_current;
        if (!m_back_request || m_back_request == m_document) {
            m_back_request = m_document->lastChild ();
            while (m_back_request->lastChild () && !m_back_request->isPlayable ())
                m_back_request = m_back_request->lastChild ();
            if (m_back_request->isPlayable ())
                return;
        }
        while (m_back_request && m_back_request != m_document) {
            if (m_back_request->previousSibling ()) {
                m_back_request = m_back_request->previousSibling ();
                NodePtr e = findDepthFirst (m_back_request); // lastDepth..
                if (e) {
                    m_back_request = e;
                    if (m_player->playing ())
                        m_player->process ()->stop ();
                    else if (m_current) {
                        m_document->reset ();
                        m_current = e;
                        TQTimer::singleShot (0, this, TQ_SLOT (playCurrent ()));
                    }
                    return;
                }
            } else
                m_back_request = m_back_request->parentNode ();
        }
        m_back_request = 0L;
    } else
        m_player->process ()->seek (-1 * m_player->settings ()->seektime * 10, false);
}

void Source::forward () {
    if (m_document->hasChildNodes ()) {
        if (m_player->playing ())
            m_player->process ()->stop ();
        else if (m_current)
            m_current->finish ();
    } else
        m_player->process ()->seek (m_player->settings()->seektime * 10, false);
}

void Source::jump (NodePtr e) {
    if (e->isPlayable ()) {
        if (m_player->playing ()) {
            m_back_request = e;
            m_player->process ()->stop ();
        } else {
            if (m_current)
                m_document->reset ();
            m_current = e;
            TQTimer::singleShot (0, this, TQ_SLOT (playCurrent ()));
        }
    } else
        m_player->updateTree ();
}

NodePtr Source::document () {
    if (!m_document)
        m_document = new Document (TQString (), this);
    return m_document;
}

NodePtr Source::root () {
    return document ();
}

bool Source::processOutput (const TQString &) {
    return false;
}

TQString Source::filterOptions () {
    Settings* m_settings = m_player->settings ();
    TQString PPargs ("");
    if (m_settings->postprocessing)
    {
        if (m_settings->pp_default)
            PPargs = "-vf pp=de";
        else if (m_settings->pp_fast)
            PPargs = "-vf pp=fa";
        else if (m_settings->pp_custom) {
            PPargs = "-vf pp=";
            if (m_settings->pp_custom_hz) {
                PPargs += "hb";
                if (m_settings->pp_custom_hz_aq && \
                        m_settings->pp_custom_hz_ch)
                    PPargs += ":ac";
                else if (m_settings->pp_custom_hz_aq)
                    PPargs += ":a";
                else if (m_settings->pp_custom_hz_ch)
                    PPargs += ":c";
                PPargs += '/';
            }
            if (m_settings->pp_custom_vt) {
                PPargs += "vb";
                if (m_settings->pp_custom_vt_aq && \
                        m_settings->pp_custom_vt_ch)
                    PPargs += ":ac";
                else if (m_settings->pp_custom_vt_aq)
                    PPargs += ":a";
                else if (m_settings->pp_custom_vt_ch)
                    PPargs += ":c";
                PPargs += '/';
            }
            if (m_settings->pp_custom_dr) {
                PPargs += "dr";
                if (m_settings->pp_custom_dr_aq && \
                        m_settings->pp_custom_dr_ch)
                    PPargs += ":ac";
                else if (m_settings->pp_custom_dr_aq)
                    PPargs += ":a";
                else if (m_settings->pp_custom_dr_ch)
                    PPargs += ":c";
                PPargs += '/';
            }
            if (m_settings->pp_custom_al) {
                PPargs += "al";
                if (m_settings->pp_custom_al_f)
                    PPargs += ":f";
                PPargs += '/';
            }
            if (m_settings->pp_custom_tn) {
                PPargs += "tn";
                /*if (1 <= m_settings->pp_custom_tn_s <= 3){
                    PPargs += ":";
                    PPargs += m_settings->pp_custom_tn_s;
                    }*/ //disabled 'cos this is wrong
                PPargs += '/';
            }
            if (m_settings->pp_lin_blend_int) {
                PPargs += "lb";
                PPargs += '/';
            }
            if (m_settings->pp_lin_int) {
                PPargs += "li";
                PPargs += '/';
            }
            if (m_settings->pp_cub_int) {
                PPargs += "ci";
                PPargs += '/';
            }
            if (m_settings->pp_med_int) {
                PPargs += "md";
                PPargs += '/';
            }
            if (m_settings->pp_ffmpeg_int) {
                PPargs += "fd";
                PPargs += '/';
            }
        }
        if (PPargs.endsWith("/"))
            PPargs.truncate(PPargs.length()-1);
    }
    return PPargs;
}

bool Source::hasLength () {
    return true;
}

bool Source::isSeekable () {
    return true;
}

void Source::setIdentified (bool b) {
    //kdDebug () << "Source::setIdentified " << m_identified << b <<endl;
    m_identified = b;
}

static const TQString statemap [] = {
    i18n ("Not Running"), i18n ("Ready"), i18n ("Buffering"), i18n ("Playing")
};

void Source::stateChange(Process *p, Process::State olds, Process::State news) {
    if (!p || !p->viewer ()) return;
    Recorder *rec = dynamic_cast <Recorder *> (p);
    if (rec && !rec->recordURL ().isEmpty ()) {
        kdDebug () << "recordState " << statemap[olds] << " -> " << statemap[news] << endl;
        m_player->updateStatus (i18n ("Recorder %1 %2").arg (p->name ()).arg (statemap[news]));
        p->viewer ()->view ()->controlPanel ()->setRecording (news > Process::Ready);
        if (news == Process::Ready) {
            if (olds > Process::Ready) {
                p->quit ();
            } else {
                NodePtr n = current ();
                if (!n)
                    n = document ();
                p->play (this, n);
            }
        } else if (news > Process::Ready) {
            emit startRecording ();
        } else if (news == Process::NotRunning)
            emit stopRecording ();
    } else {
        p->viewer()->view()->controlPanel()->setPlaying(news > Process::Ready);
        kdDebug () << "processState " << statemap[olds] << " -> " << statemap[news] << endl;
        m_player->updateStatus (i18n ("Player %1 %2").arg (p->name ()).arg (statemap[news]));
        if (!p->mrl () && news > Process::Ready) {
            p->stop (); // reschedule for Ready state
        } else if (news == Process::Playing) {
            if (p->mrl ()->state == Element::state_deferred)
                p->mrl ()->undefer ();
            p->viewer ()->view ()->playingStart ();
            emit startPlaying ();
        } else if (news == Process::NotRunning) {
            if (hasLength () && position () > length ())
                setLength (m_document, position ());
            setPosition (0);
            if (p == m_player->process ())
                emit stopPlaying ();
            // else changed process
        } else if (news == Process::Ready) {
            if (olds > Process::Ready) {
                NodePtr node = p->mrl (); // p->mrl is weak, needs check
                Mrl * mrl = node ? node->mrl () : 0L;
                if (m_back_request && m_back_request->isPlayable ()) {
                    if (m_back_request->mrl ()->view_mode == Mrl::SingleMode)
                        // jump in pl
                        m_current = m_back_request;
                    else if (mrl)
                        // overlapping SMIL audio/video
                        mrl->endOfFile ();
                    if (m_current->id >= SMIL::id_node_first &&
                            m_current->id < SMIL::id_node_last) {
                        playCurrent ();  // just play back_request
                    } else {
                        // sanitize pl having all parents of current activated
                        m_document->reset (); // deactivate everything
                        for (NodePtr p = m_current->parentNode(); p; p = p->parentNode())
                            p->state = Element::state_activated;
                        m_current->activate (); // calls requestPlayUrl
                    }
                    m_back_request = 0L;
                } else if(mrl)
		{
                    mrl->endOfFile (); // set node to finished
		}
                if (m_player->view() &&
                        (!mrl || mrl->view_mode != Mrl::WindowMode))
                    static_cast<View*>(m_player->view())->viewArea()->repaint();
            } else
                TQTimer::singleShot (0, this, TQ_SLOT (playCurrent ()));
        } else if (news == Process::Buffering) {
            if (p->mrl ()->mrl ()->view_mode != Mrl::SingleMode)
                p->mrl ()->defer (); // paused the SMIL
        }
    }
}

TQString Source::plugin (const TQString &mime) const {
    m_player->config ()->setGroup (mime);
    return m_player->config ()->readEntry ("plugin", "" );
}

TQString Source::prettyName () {
    return i18n ("Unknown");
}

//-----------------------------------------------------------------------------

URLSource::URLSource (PartBase * player, const KURL & url)
    : Source (i18n ("URL"), player, "urlsource"), activated (false) {
    setURL (url);
    //kdDebug () << "URLSource::URLSource" << endl;
}

URLSource::~URLSource () {
    //kdDebug () << "URLSource::~URLSource" << endl;
}

void URLSource::init () {
    Source::init ();
}

void URLSource::dimensions (int & w, int & h) {
    if (!m_player->mayResize () && m_player->view ()) {
        w = static_cast <View *> (m_player->view ())->viewer ()->width ();
        h = static_cast <View *> (m_player->view ())->viewer ()->height ();
    } else
        Source::dimensions (w, h);
    
}

bool URLSource::hasLength () {
    return !!length ();
}

TDE_NO_EXPORT void URLSource::activate () {
    if (activated)
        return;
    activated = true;
    if (url ().isEmpty () && (!m_document || !m_document->hasChildNodes ())) {
        m_player->updateTree ();
        return;
    }
    if (m_auto_play)
        play ();
}

TDE_NO_EXPORT void URLSource::stopResolving () {
    if (m_resolve_info) {
        for (SharedPtr <ResolveInfo> ri = m_resolve_info; ri; ri = ri->next)
            ri->job->kill ();
        m_resolve_info = 0L;
        m_player->updateStatus (i18n ("Disconnected"));
        m_player->setLoaded (100);
    }
}

void URLSource::reset () {
    stopResolving ();
    Source::reset ();
}

void URLSource::forward () {
    stopResolving ();
    Source::forward ();
}

void URLSource::backward () {
    stopResolving ();
    Source::backward ();
}

void URLSource::jump (NodePtr e) {
    stopResolving ();
    Source::jump (e);
}

void URLSource::deactivate () {
    activated = false;
    reset ();
    getSurface (0L);
}

TQString URLSource::prettyName () {
    if (m_url.isEmpty ())
        return i18n ("URL");
    if (m_url.url ().length () > 50) {
        TQString newurl = m_url.protocol () + TQString ("://");
        if (m_url.hasHost ())
            newurl += m_url.host ();
        if (m_url.port ())
            newurl += TQString (":%1").arg (m_url.port ());
        TQString file = m_url.fileName ();
        int len = newurl.length () + file.length ();
        KURL path = KURL (m_url.directory ());
        bool modified = false;
        while (path.url ().length () + len > 50 && path != path.upURL ()) {
            path = path.upURL ();
            modified = true;
        }
        TQString dir = path.directory ();
        if (!dir.endsWith (TQString ("/")))
            dir += '/';
        if (modified)
            dir += TQString (".../");
        newurl += dir + file;
        return i18n ("URL - %1").arg (newurl);
    }
    return i18n ("URL - %1").arg (m_url.prettyURL ());
}

static bool isPlayListMime (const TQString & mime) {
    TQString m (mime);
    int plugin_pos = m.find ("-plugin");
    if (plugin_pos > 0)
        m.truncate (plugin_pos);
    const char * mimestr = m.ascii ();
    return mimestr && (!strcmp (mimestr, "audio/mpegurl") ||
            !strcmp (mimestr, "audio/x-mpegurl") ||
            !strncmp (mimestr, "video/x-ms", 10) ||
            !strncmp (mimestr, "audio/x-ms", 10) ||
            //!strcmp (mimestr, "video/x-ms-wmp") ||
            //!strcmp (mimestr, "video/x-ms-asf") ||
            //!strcmp (mimestr, "video/x-ms-wmv") ||
            //!strcmp (mimestr, "video/x-ms-wvx") ||
            //!strcmp (mimestr, "video/x-msvideo") ||
            !strcmp (mimestr, "audio/x-scpls") ||
            !strcmp (mimestr, "audio/x-pn-realaudio") ||
            !strcmp (mimestr, "audio/vnd.rn-realaudio") ||
            !strcmp (mimestr, "audio/m3u") ||
            !strcmp (mimestr, "audio/x-m3u") ||
            !strncmp (mimestr, "text/", 5) ||
            (!strncmp (mimestr, "application/", 12) &&
             strstr (mimestr + 12,"+xml")) ||
            !strncasecmp (mimestr, "application/smil", 16) ||
            !strncasecmp (mimestr, "application/xml", 15) ||
            //!strcmp (mimestr, "application/rss+xml") ||
            //!strcmp (mimestr, "application/atom+xml") ||
            !strcmp (mimestr, "application/x-mplayer2"));
}

TDE_NO_EXPORT void URLSource::read (NodePtr root, TQTextStream & textstream) {
    TQString line;
    do {
        line = textstream.readLine ();
    } while (!line.isNull () && line.stripWhiteSpace ().isEmpty ());
    if (!line.isNull ()) {
        NodePtr cur_elm = root;
        if (cur_elm->isPlayable ())
            cur_elm = cur_elm->mrl ()->linkNode ();
        if (cur_elm->mrl ()->mimetype == TQString ("audio/x-scpls")) {
            bool groupfound = false;
            int nr = -1;
            struct Entry {
                TQString url, title;
            } * entries = 0L;
            do {
                line = line.stripWhiteSpace ();
                if (!line.isEmpty ()) {
                    if (line.startsWith (TQString ("[")) && line.endsWith (TQString ("]"))) {
                        if (!groupfound && line.mid (1, line.length () - 2).stripWhiteSpace () == TQString ("playlist"))
                            groupfound = true;
                        else
                            break;
                        kdDebug () << "Group found: " << line << endl;
                    } else if (groupfound) {
                        int eq_pos = line.find (TQChar ('='));
                        if (eq_pos > 0) {
                            if (line.lower ().startsWith (TQString ("numberofentries"))) {
                                nr = line.mid (eq_pos + 1).stripWhiteSpace ().toInt ();
                                kdDebug () << "numberofentries : " << nr << endl;
                                if (nr > 0 && nr < 1024)
                                    entries = new Entry[nr];
                                else
                                    nr = 0;
                            } else if (nr > 0) {
                                TQString ll = line.lower ();
                                if (ll.startsWith (TQString ("file"))) {
                                    int i = line.mid (4, eq_pos-4).toInt ();
                                    if (i > 0 && i <= nr)
                                        entries[i-1].url = line.mid (eq_pos + 1).stripWhiteSpace ();
                                } else if (ll.startsWith (TQString ("title"))) {
                                    int i = line.mid (5, eq_pos-5).toInt ();
                                    if (i > 0 && i <= nr)
                                        entries[i-1].title = line.mid (eq_pos + 1).stripWhiteSpace ();
                                }
                            }
                        }
                    }
                }
                line = textstream.readLine ();
            } while (!line.isNull ());
            for (int i = 0; i < nr; i++)
                if (!entries[i].url.isEmpty ())
                    cur_elm->appendChild (new GenericURL (m_document, KURL::decode_string (entries[i].url), entries[i].title));
            delete [] entries;
        } else if (line.stripWhiteSpace ().startsWith (TQChar ('<'))) {
            readXML (cur_elm, textstream, line);
            //cur_elm->normalize ();
            if (m_document && m_document->firstChild ()) {
                // SMIL documents have set its size of root-layout
                Mrl * mrl = m_document->firstChild ()->mrl ();
                if (mrl)
                    Source::setDimensions (m_document->firstChild (), mrl->width, mrl->height);
            }
        } else if (line.lower () != TQString ("[reference]")) do {
            TQString mrl = line.stripWhiteSpace ();
            if (line == TQString ("--stop--"))
                break;
            if (mrl.lower ().startsWith (TQString ("asf ")))
                mrl = mrl.mid (4).stripWhiteSpace ();
            if (!mrl.isEmpty () && !mrl.startsWith (TQChar ('#')))
                cur_elm->appendChild (new GenericURL (m_document, mrl));
            line = textstream.readLine ();
        } while (!line.isNull ()); /* TODO && m_document.size () < 1024 / * support 1k entries * /);*/
    }
}

TDE_NO_EXPORT void URLSource::kioData (TDEIO::Job * job, const TQByteArray & d) {
    SharedPtr <ResolveInfo> rinfo = m_resolve_info;
    while (rinfo && rinfo->job != job)
        rinfo = rinfo->next;
    if (!rinfo) {
        kdWarning () << "Spurious kioData" << endl;
        return;
    }
    int size = rinfo->data.size ();
    int newsize = size + d.size ();
    if (!size) { // first data
        int accuraty = 0;
        KMimeType::Ptr mime = KMimeType::findByContent (d, &accuraty);
        if (!mime ||
                !mime->name ().startsWith (TQString ("text/")) ||
                (newsize > 4 && !strncmp (d.data (), "RIFF", 4))) {
            newsize = 0;
            kdDebug () << "URLSource::kioData: " << mime->name () << accuraty << endl;
        }
    }
    //kdDebug () << "URLSource::kioData: " << newsize << endl;
    if (newsize <= 0 || newsize > 200000) {
        rinfo->data.resize (0);
        rinfo->job->kill (false);
        m_player->setLoaded (100);
    } else  {
        rinfo->data.resize (newsize);
        memcpy (rinfo->data.data () + size, d.data (), newsize - size);
        m_player->setLoaded (++rinfo->progress);
    }
}

TDE_NO_EXPORT void URLSource::kioMimetype (TDEIO::Job * job, const TQString & mimestr) {
    SharedPtr <ResolveInfo> rinfo = m_resolve_info;
    while (rinfo && rinfo->job != job)
        rinfo = rinfo->next;
    if (!rinfo) {
        kdWarning () << "Spurious kioData" << endl;
        return;
    }
    if (rinfo->resolving_mrl)
        rinfo->resolving_mrl->mrl ()->mimetype = mimestr;
    if (!rinfo->resolving_mrl || !isPlayListMime (mimestr))
        job->kill (false);
}

TDE_NO_EXPORT void URLSource::kioResult (TDEIO::Job * job) {
    SharedPtr <ResolveInfo> previnfo, rinfo = m_resolve_info;
    while (rinfo && rinfo->job != job) {
        previnfo = rinfo;
        rinfo = rinfo->next;
    }
    if (!rinfo) {
        kdWarning () << "Spurious kioData" << endl;
        return;
    }
    m_player->updateStatus ("");
    m_player->setLoaded (100);
    if (previnfo)
        previnfo->next = rinfo->next;
    else
        m_resolve_info = rinfo->next;
    TQTextStream textstream (rinfo->data, IO_ReadOnly);
    if (rinfo->resolving_mrl) {
        if (isPlayListMime (rinfo->resolving_mrl->mrl ()->mimetype))
            read (rinfo->resolving_mrl, textstream);
        rinfo->resolving_mrl->mrl ()->resolved = true;
        rinfo->resolving_mrl->undefer ();
    }
    static_cast <View *> (m_player->view())->controlPanel()->setPlaying (false);
}

void URLSource::playCurrent () {
    Mrl *mrl = m_back_request
        ? m_back_request->mrl ()
        : m_current ? m_current->mrl () : NULL;
    if (mrl && mrl->active () && (!mrl->isPlayable () || !mrl->resolved))
        // an async playCurrent() call (eg. backend is up & running), ignore
        return;
    Source::playCurrent ();
}

void URLSource::play () {
    Source::play ();
}

bool URLSource::requestPlayURL (NodePtr mrl) {
    if (m_document.ptr () != mrl->mrl ()->linkNode ()) {
        KURL base = m_document->mrl ()->src;
        KURL dest = mrl->mrl ()->linkNode ()->absolutePath ();
        // check if some remote playlist tries to open something local, but
        // do ignore unknown protocols because there are so many and we only
        // want to cache local ones.
        if (
#if 0
            !KProtocolInfo::protocolClass (dest.protocol ()).isEmpty () &&
#else
            dest.isLocalFile () &&
#endif
                !kapp->authorizeURLAction ("redirect", base, dest)) {
            kdWarning () << "requestPlayURL from document " << base << " to play " << dest << " is not allowed" << endl;
            return false;
        }
    }
    return Source::requestPlayURL (mrl);
}

void URLSource::setURL (const KURL & url) {
    Source::setURL (url);
    Mrl *mrl = document ()->mrl ();
    if (!url.isEmpty () && url.isLocalFile () && mrl->mimetype.isEmpty ()) {
        KMimeType::Ptr mimeptr = KMimeType::findByURL (url);
        if (mimeptr)
            mrl->mimetype = mimeptr->name ();
    }
}

bool URLSource::resolveURL (NodePtr m) {
    Mrl * mrl = m->mrl ();
    if (!mrl || mrl->src.isEmpty ())
        return true;
    int depth = 0;
    for (NodePtr e = m->parentNode (); e; e = e->parentNode ())
        ++depth;
    if (depth > 40)
        return true;
    KURL url (mrl->absolutePath ());
    TQString mimestr = mrl->mimetype;
    if (mimestr == "application/x-shockwave-flash" ||
            mimestr == "application/futuresplash")
        return true; // FIXME
    bool maybe_playlist = isPlayListMime (mimestr);
    kdDebug () << "resolveURL " << mrl->absolutePath () << " " << mimestr << endl;
    if (url.isLocalFile ()) {
        TQFile file (url.path ());
        if (!file.exists ()) {
            kdWarning () << "resolveURL " << url.path() << " not found" << endl;
            return true;
        }
        if (mimestr.isEmpty ()) {
            KMimeType::Ptr mimeptr = KMimeType::findByURL (url);
            if (mimeptr) {
                mrl->mimetype = mimeptr->name ();
                maybe_playlist = isPlayListMime (mrl->mimetype); // get new mime
            }
        }
        if (maybe_playlist && file.size () < 2000000 && file.open (IO_ReadOnly)) {
            char databuf [512];
            int nr_bytes = file.readBlock (databuf, 512);
            if (nr_bytes > 3) {
                int accuraty = 0;
                KMimeType::Ptr mime = KMimeType::findByContent (TQCString (databuf, nr_bytes), &accuraty);
                if ((mime && !mime->name().startsWith (TQString("text/"))) ||
                        !strncmp (databuf, "RIFF", 4)) {
                    return true;
                }
                kdDebug () << "mime: " << (mime ? mime->name (): TQString("null")) << endl;
            }
            file.reset ();
            TQTextStream textstream (&file);
            read (m, textstream);
        }
    } else if ((maybe_playlist &&
                url.protocol ().compare (TQString ("mms")) &&
                url.protocol ().compare (TQString ("rtsp")) &&
                url.protocol ().compare (TQString ("rtp"))) ||
            (mimestr.isEmpty () &&
             (url.protocol ().startsWith (TQString ("http")) || 
              url.protocol () == TQString::fromLatin1 ("media") ||
              url.protocol () == TQString::fromLatin1 ("remote")))) {
        TDEIO::Job * job = TDEIO::get (url, false, false);
        job->addMetaData ("PropagateHttpHeader", "true");
        job->addMetaData ("errorPage", "false");
        m_resolve_info = new ResolveInfo (m, job, m_resolve_info);
        connect (m_resolve_info->job, TQ_SIGNAL(data(TDEIO::Job*,const TQByteArray&)),
                this, TQ_SLOT (kioData (TDEIO::Job *, const TQByteArray &)));
        //connect( m_job, TQ_SIGNAL(connected(TDEIO::Job*)),
        //         this, TQ_SLOT(slotConnected(TDEIO::Job*)));
        connect(m_resolve_info->job, TQ_SIGNAL(mimetype(TDEIO::Job*,const TQString&)),
                this, TQ_SLOT (kioMimetype (TDEIO::Job *, const TQString &)));
        connect (m_resolve_info->job, TQ_SIGNAL (result (TDEIO::Job *)),
                this, TQ_SLOT (kioResult (TDEIO::Job *)));
        static_cast <View *> (m_player->view ())->controlPanel ()->setPlaying (true);
        m_player->updateStatus (i18n ("Connecting"));
        m_player->setLoaded (0);
        return false; // wait for result ..
    }
    return true;
}

//-----------------------------------------------------------------------------

namespace KMPlayer {
    static KStaticDeleter <DataCache> dataCacheDeleter;
    static DataCache * memory_cache;
}

void DataCache::add (const TQString & url, const TQByteArray & data) {
    TQByteArray bytes;
    bytes.duplicate (data);
    cache_map.insert (url, bytes);
    preserve_map.erase (url);
    emit preserveRemoved (url);
}

bool DataCache::get (const TQString & url, TQByteArray & data) {
    DataMap::const_iterator it = cache_map.find (url);
    if (it != cache_map.end ()) {
        data.duplicate (it.data ());
        return true;
    }
    return false;
}

bool DataCache::preserve (const TQString & url) {
    PreserveMap::const_iterator it = preserve_map.find (url);
    if (it == preserve_map.end ()) {
        preserve_map.insert (url, true);
        return true;
    }
    return false;
}

bool DataCache::isPreserved (const TQString & url) {
    return preserve_map.find (url) != preserve_map.end ();
}

bool DataCache::unpreserve (const TQString & url) {
    const PreserveMap::iterator it = preserve_map.find (url);
    if (it == preserve_map.end ())
        return false;
    preserve_map.erase (it);
    emit preserveRemoved (url);
    return true;
}

RemoteObjectPrivate::RemoteObjectPrivate (RemoteObject * r)
 : job (0L), remote_object (r), preserve_wait (false) {
    if (!memory_cache)
        dataCacheDeleter.setObject (memory_cache, new DataCache);
}

RemoteObjectPrivate::~RemoteObjectPrivate () {
    clear ();
}

TDE_NO_EXPORT bool RemoteObjectPrivate::download (const TQString & str) {
    url = str;
    KURL kurl (str);
    if (kurl.isLocalFile ()) {
        TQFile file (kurl.path ());
        if (file.exists () && file.open (IO_ReadOnly)) {
            data = file.readAll ();
            file.close ();
        }
        remote_object->remoteReady (data);
        return true;
    }
    if (memory_cache->get (str, data)) {
        //kdDebug () << "download found in cache " << str << endl;
        remote_object->remoteReady (data);
        return true;
    }
    if (memory_cache->preserve (str)) {
        //kdDebug () << "downloading " << str << endl;
        job = TDEIO::get (kurl, false, false);
        connect (job, TQ_SIGNAL (data (TDEIO::Job *, const TQByteArray &)),
                this, TQ_SLOT (slotData (TDEIO::Job *, const TQByteArray &)));
        connect (job, TQ_SIGNAL (result (TDEIO::Job *)),
                this, TQ_SLOT (slotResult (TDEIO::Job *)));
        connect (job, TQ_SIGNAL (mimetype (TDEIO::Job *, const TQString &)),
                this, TQ_SLOT (slotMimetype (TDEIO::Job *, const TQString &)));
    } else {
        //kdDebug () << "download preserved " << str << endl;
        connect (memory_cache, TQ_SIGNAL (preserveRemoved (const TQString &)),
                 this, TQ_SLOT (cachePreserveRemoved (const TQString &)));
        preserve_wait = true;
    }
    return false;
}

TDE_NO_EXPORT void RemoteObjectPrivate::clear () {
    if (job) {
        job->kill (); // quiet, no result signal
        job = 0L;
        memory_cache->unpreserve (url);
    } else if (preserve_wait) {
        disconnect (memory_cache, TQ_SIGNAL (preserveRemoved (const TQString &)),
                    this, TQ_SLOT (cachePreserveRemoved (const TQString &)));
        preserve_wait = false;
    }
}

TDE_NO_EXPORT void RemoteObjectPrivate::slotResult (TDEIO::Job * kjob) {
    if (!kjob->error ())
        memory_cache->add (url, data);
    else
        data.resize (0);
    job = 0L; // signal TDEIO::Job::result deletes itself
    remote_object->remoteReady (data);
}

TDE_NO_EXPORT
void RemoteObjectPrivate::cachePreserveRemoved (const TQString & str) {
    if (str == url && !memory_cache->isPreserved (str)) {
        preserve_wait = false;
        disconnect (memory_cache, TQ_SIGNAL (preserveRemoved (const TQString &)),
                    this, TQ_SLOT (cachePreserveRemoved (const TQString &)));
        download (str);
    }
}

TDE_NO_EXPORT
void RemoteObjectPrivate::slotData (TDEIO::Job*, const TQByteArray& qb) {
    if (qb.size ()) {
        int old_size = data.size ();
        data.resize (old_size + qb.size ());
        memcpy (data.data () + old_size, qb.data (), qb.size ());
    }
}

TDE_NO_EXPORT
void RemoteObjectPrivate::slotMimetype (TDEIO::Job *, const TQString & m) {
    mime = m;
}

KDE_NO_CDTOR_EXPORT RemoteObject::RemoteObject ()
 : d (new RemoteObjectPrivate (this)) {}

KDE_NO_CDTOR_EXPORT RemoteObject::~RemoteObject () {
    delete d;
}

/**
 * abort previous wget job
 */
TDE_NO_EXPORT void RemoteObject::killWGet () {
    d->clear (); // assume data is invalid
}

/**
 * Gets contents from url and puts it in m_data
 */
TDE_NO_EXPORT bool RemoteObject::wget (const TQString & url) {
    clear ();
    return d->download (url);
}

TDE_NO_EXPORT TQString RemoteObject::mimetype () {
    if (d->data.size () > 0 && d->mime.isEmpty ()) {
        int accuraty;
        KMimeType::Ptr mime = KMimeType::findByContent (d->data, &accuraty);
        if (mime)
            d->mime = mime->name ();
    }
    return d->mime;
}

TDE_NO_EXPORT void RemoteObject::clear () {
    killWGet ();
    d->url.truncate (0);
    d->mime.truncate (0);
    d->data.resize (0);
}

TDE_NO_EXPORT bool RemoteObject::downloading () const {
    return !!d->job;
}

//-----------------------------------------------------------------------------

#include "kmplayerpartbase.moc"
#include "kmplayersource.moc"
