kompare_part.cpp

Go to the documentation of this file.

/***************************************************************************
                                kompare_part.cpp
                                ----------------
        begin                   : Sun Mar 4 2001
        Copyright 2001-2005,2009 Otto Bruggeman <bruggie@gmail.com>
        Copyright 2001-2003 John Firebaugh <jfirebaugh@kde.org>
        Copyright 2004      Jeff Snyder    <jeff@caffeinated.me.uk>
        Copyright 2007-2011 Kevin Kofler   <kevin.kofler@chello.at>
        Copyright 2012     Jean-Nicolas Artaud <jeannicolasartaud@gmail.com>
****************************************************************************/

/***************************************************************************
**
**   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 2 of the License, or
**   (at your option) any later version.
**
***************************************************************************/

#include "kompare_part.h"

#include <QtGui/QLayout>
#include <QtGui/QWidget>
#include <QPainter>
#include <QPrinter>
#include <QPrintDialog>
#include <QPrintPreviewDialog>

#include <kaboutdata.h>
#include <kaction.h>
#include <kactioncollection.h>
#include <kapplication.h>
#include <kcomponentdata.h>
#include <kdebug.h>
#include <kdeprintdialog.h>
#include <kfiledialog.h>
#include <klocale.h>
#include <kmessagebox.h>
#include <kstandardaction.h>
#include <kstandarddirs.h>
#include <kstandardshortcut.h>
#include <ktemporaryfile.h>
#include <ktempdir.h>

#include <kio/netaccess.h>
#include <kglobal.h>

#include "diffmodel.h"
#include "komparelistview.h"
#include "kompareconnectwidget.h"
#include "diffsettings.h"
#include "viewsettings.h"
#include "kompareprefdlg.h"
#include "komparesaveoptionswidget.h"
#include "komparesplitter.h"
#include "kompareview.h"

K_PLUGIN_FACTORY( KomparePartFactory, registerPlugin<KomparePart>(); )
K_EXPORT_PLUGIN( KomparePartFactory )

ViewSettings* KomparePart::m_viewSettings = 0L;
DiffSettings* KomparePart::m_diffSettings = 0L;

KomparePart::KomparePart( QWidget *parentWidget, QObject *parent, const QVariantList & /*args*/ ) :
    KParts::ReadWritePart(parent),
    m_tempDiff( 0 ),
    m_info()
{
    if( !m_viewSettings ) {
        m_viewSettings = new ViewSettings( 0 );
    }
    if( !m_diffSettings ) {
        m_diffSettings = new DiffSettings( 0 );
    }

    readProperties( KGlobal::config().data() );

    m_view = new KompareView ( m_viewSettings, parentWidget );
    setWidget( m_view );
    m_splitter = m_view->splitter();

    // This creates the "Model creator" and connects the signals and slots
    m_modelList = new Diff2::KompareModelList( m_diffSettings, m_splitter, this, "komparemodellist" , KParts::ReadWritePart::isReadWrite());

    Q_FOREACH(QAction* action, m_modelList->actionCollection()->actions())
    {
        actionCollection()->addAction(action->objectName(), action);
    }
    connect( m_modelList, SIGNAL(status( Kompare::Status )),
             this, SLOT(slotSetStatus( Kompare::Status )) );
    connect( m_modelList, SIGNAL(setStatusBarModelInfo( int, int, int, int, int )),
             this, SIGNAL(setStatusBarModelInfo( int, int, int, int, int )) );
    connect( m_modelList, SIGNAL(error( QString )),
             this, SLOT(slotShowError( QString )) );
    connect( m_modelList, SIGNAL(applyAllDifferences( bool )),
             this, SLOT(updateActions()) );
    connect( m_modelList, SIGNAL(applyDifference( bool )),
             this, SLOT(updateActions()) );
    connect( m_modelList, SIGNAL(applyAllDifferences( bool )),
             this, SIGNAL(appliedChanged()) );
    connect( m_modelList, SIGNAL(applyDifference( bool )),
             this, SIGNAL(appliedChanged()) );
    connect( m_modelList, SIGNAL(updateActions()), this, SLOT(updateActions()) );

    // This is the stuff to connect the "interface" of the kompare part to the model inside
    connect( m_modelList, SIGNAL(modelsChanged(const Diff2::DiffModelList*)),
             this, SIGNAL(modelsChanged(const Diff2::DiffModelList*)) );

    connect( m_modelList, SIGNAL(setSelection(const Diff2::DiffModel*, const Diff2::Difference*)),
             this, SIGNAL(setSelection(const Diff2::DiffModel*, const Diff2::Difference*)) );
    connect( this, SIGNAL(selectionChanged(const Diff2::DiffModel*, const Diff2::Difference*)),
             m_modelList, SLOT(slotSelectionChanged(const Diff2::DiffModel*, const Diff2::Difference*)) );

    connect( m_modelList, SIGNAL(setSelection(const Diff2::Difference*)),
             this, SIGNAL(setSelection(const Diff2::Difference*)) );
    connect( this, SIGNAL(selectionChanged(const Diff2::Difference*)),
             m_modelList, SLOT(slotSelectionChanged(const Diff2::Difference*)) );

    connect( m_modelList, SIGNAL(applyDifference(bool)),
             this, SIGNAL(applyDifference(bool)) );
    connect( m_modelList, SIGNAL(applyAllDifferences(bool)),
             this, SIGNAL(applyAllDifferences(bool)) );
    connect( m_modelList, SIGNAL(applyDifference(const Diff2::Difference*, bool)),
             this, SIGNAL(applyDifference(const Diff2::Difference*, bool)) );
    connect( m_modelList, SIGNAL(diffString(const QString&)),
             this, SIGNAL(diffString(const QString&)) );

    connect( this, SIGNAL(kompareInfo(Kompare::Info*)), m_modelList, SLOT(slotKompareInfo(Kompare::Info*)) );

    // Here we connect the splitter to the modellist
    connect( m_modelList, SIGNAL(setSelection(const Diff2::DiffModel*, const Diff2::Difference*)),
             m_splitter,  SLOT(slotSetSelection(const Diff2::DiffModel*, const Diff2::Difference*)) );
//  connect( m_splitter,  SIGNAL(selectionChanged(const Diff2::Difference*, const Diff2::Difference*)),
//           m_modelList, SLOT(slotSelectionChanged(const Diff2::Difference*, const Diff2::Difference*)) );
    connect( m_modelList, SIGNAL(setSelection(const Diff2::Difference*)),
             m_splitter,  SLOT(slotSetSelection(const Diff2::Difference*)) );
    connect( m_splitter,  SIGNAL(selectionChanged(const Diff2::Difference*)),
             m_modelList, SLOT(slotSelectionChanged(const Diff2::Difference*)) );

    connect( m_modelList, SIGNAL(applyDifference(bool)),
             m_splitter, SLOT(slotApplyDifference(bool)) );
    connect( m_modelList, SIGNAL(applyAllDifferences(bool)),
             m_splitter, SLOT(slotApplyAllDifferences(bool)) );
    connect( m_modelList, SIGNAL(applyDifference(const Diff2::Difference*, bool)),
             m_splitter, SLOT(slotApplyDifference(const Diff2::Difference*, bool)) );
    connect( this, SIGNAL(configChanged()), m_splitter, SIGNAL(configChanged()) );

    setupActions();

    // set our XML-UI resource file
    setXMLFile( "komparepartui.rc" );

    // we are read-write by default -> uhm what if we are opened by lets say konq in RO mode ?
    // Then we should not be doing this...
    setReadWrite( true );

    // we are not modified since we haven't done anything yet
    setModified( false );
}

KomparePart::~KomparePart()
{
    // This is the only place allowed to call cleanUpTemporaryFiles
    // because before there might still be a use for them (when swapping)
    cleanUpTemporaryFiles();
}

void KomparePart::setupActions()
{
    // create our actions

    m_saveAll = actionCollection()->addAction("file_save_all", this, SLOT(saveAll()));
    m_saveAll->setIcon(KIcon("document-save-all"));
    m_saveAll->setText(i18n("Save &All"));
    m_saveDiff = actionCollection()->addAction("file_save_diff", this, SLOT(saveDiff()));
    m_saveDiff->setText(i18n("Save &Diff..."));
    m_swap = actionCollection()->addAction("file_swap", this, SLOT(slotSwap()));
    m_swap->setText(i18n("Swap Source with Destination"));
    m_diffStats = actionCollection()->addAction("file_diffstats", this, SLOT(slotShowDiffstats()));
    m_diffStats->setText(i18n("Show Statistics"));
    m_diffRefresh = actionCollection()->addAction("file_refreshdiff", this, SLOT(slotRefreshDiff()));
    m_diffRefresh->setIcon(KIcon("view-refresh"));
    m_diffRefresh->setText(i18n("Refresh Diff"));
    m_diffRefresh->setShortcut(KStandardShortcut::reload());

    m_print        = actionCollection()->addAction(KStandardAction::Print, this, SLOT( slotFilePrint() ));
    m_printPreview = actionCollection()->addAction(KStandardAction::PrintPreview, this, SLOT( slotFilePrintPreview() ));
    KStandardAction::preferences(this, SLOT(optionsPreferences()), actionCollection());
}

void KomparePart::updateActions()
{
    m_saveAll->setEnabled     ( m_modelList->hasUnsavedChanges() );
    m_saveDiff->setEnabled    ( m_modelList->mode() == Kompare::ComparingFiles || m_modelList->mode() == Kompare::ComparingDirs );
    m_swap->setEnabled        ( m_modelList->mode() == Kompare::ComparingFiles || m_modelList->mode() == Kompare::ComparingDirs );
    m_diffRefresh->setEnabled ( m_modelList->mode() == Kompare::ComparingFiles || m_modelList->mode() == Kompare::ComparingDirs );
    m_diffStats->setEnabled   ( m_modelList->modelCount() > 0 );
    m_print->setEnabled       ( m_modelList->modelCount() > 0 ); // If modellist has models then we have something to print, it's that simple.
    m_printPreview->setEnabled( m_modelList );
}

void KomparePart::setEncoding( const QString& encoding )
{
    kDebug(8103) << "Encoding: " << encoding << endl;
    m_modelList->setEncoding( encoding );
}

bool KomparePart::openDiff( const KUrl& url )
{
    kDebug(8103) << "Url = " << url.url() << endl;

    m_info.mode = Kompare::ShowingDiff;
    m_info.source = url;
    bool result = false;
    fetchURL( url, true );

    emit kompareInfo( &m_info );

    if ( !m_info.localSource.isEmpty() )
    {
        kDebug(8103) << "Download succeeded " << endl;
        result = m_modelList->openDiff( m_info.localSource );
        updateActions();
        updateCaption();
        updateStatus();
    }
    else
    {
        kDebug(8103) << "Download failed !" << endl;
    }

    return result;
}

bool KomparePart::openDiff( const QString& diffOutput )
{
    bool value = false;

    m_info.mode = Kompare::ShowingDiff;

    emit kompareInfo( &m_info );

    if ( m_modelList->parseAndOpenDiff( diffOutput ) == 0 )
    {
        value = true;
        updateActions();
        updateCaption();
        updateStatus();
    }

    return value;
}

bool KomparePart::openDiff3( const KUrl& diff3Url )
{
    // FIXME: Implement this !!!
    kDebug(8103) << "Not implemented yet. Filename is: " << diff3Url.prettyUrl() << endl;
    return false;
}

bool KomparePart::openDiff3( const QString& diff3Output )
{
    // FIXME: Implement this !!!
    kDebug(8103) << "Not implemented yet. diff3 output is: " << endl;
    kDebug(8103) << diff3Output << endl;
    return false;
}

bool KomparePart::exists( const QString& url )
{
    QFileInfo fi( url );
    return fi.exists();
}

bool KomparePart::fetchURL( const KUrl& url, bool addToSource )
{
    // Default value if there is an error is "", we rely on it!
    QString tempFileName( "" );
    // Only in case of error do we set result to false, don't forget!!
    bool result = true;
    KTempDir* tmpDir = 0;

    if ( !url.isLocalFile() )
    {
        KIO::UDSEntry node;
        KIO::NetAccess::stat( url, node, widget() );
        if ( !node.isDir() )
        {
            if ( ! KIO::NetAccess::download( url, tempFileName, widget() ) )
            {
                slotShowError( i18n( "<qt>The URL <b>%1</b> cannot be downloaded.</qt>", url.prettyUrl() ) );
                tempFileName = ""; // Not sure if download has already touched this tempFileName when there is an error
                result = false;
            }
        }
        else
        {
            tmpDir = new KTempDir(KStandardDirs::locateLocal("tmp", "kompare"));
            tmpDir->setAutoRemove( true ); // Yes this is the default but just to make sure
            if ( ! KIO::NetAccess::dircopy( url, KUrl( tmpDir->name() ), widget() ) )
            {
                slotShowError( i18n( "<qt>The URL <b>%1</b> cannot be downloaded.</qt>", url.prettyUrl() ) );
                delete tmpDir;
                tmpDir = 0;
                result = false;
            }
            else
            {
                tempFileName = tmpDir->name();
                kDebug(8101) << "tempFileName = " << tempFileName << endl;
                // If a directory is copied into KTempDir then the directory in 
                // here is what I need to add to tempFileName
                QDir dir( tempFileName );
                QStringList entries = dir.entryList( QDir::Dirs | QDir::NoDotAndDotDot );
                if ( entries.size() == 1 ) // More than 1 entry in here means big problems!!!
                {
                    if ( !tempFileName.endsWith( '/' ) )
                        tempFileName += '/';
                    tempFileName += entries.at( 0 );
                    tempFileName += '/';
                }
                else
                {
                    kDebug(8101) << "Yikes, nothing downloaded?" << endl;
                    delete tmpDir;
                    tmpDir = 0;
                    tempFileName = "";
                    result = false;
                }
            }
        }
    }
    else
    {
        // is Local already, check if exists
        if ( exists( url.toLocalFile() ) )
            tempFileName = url.toLocalFile();
        else
        {
            slotShowError( i18n( "<qt>The URL <b>%1</b> does not exist on your system.</qt>", url.prettyUrl() ) );
            result = false;
        }
    }

    if ( addToSource )
    {
        m_info.localSource = tempFileName;
        m_info.sourceKTempDir = tmpDir;
    }
    else
    {
        m_info.localDestination = tempFileName;
        m_info.destinationKTempDir = tmpDir;
    }

    return result;
}

void KomparePart::cleanUpTemporaryFiles()
{
    kDebug(8101) << "Cleaning temporary files." << endl;
    if ( !m_info.localSource.isEmpty() )
    {
        if ( m_info.sourceKTempDir == 0 )
            KIO::NetAccess::removeTempFile( m_info.localSource );
        else
        {
            delete m_info.sourceKTempDir;
            m_info.sourceKTempDir = 0;
        }
        m_info.localSource = "";
    }
    if ( !m_info.localDestination.isEmpty() )
    {
        if ( m_info.destinationKTempDir == 0  )
            KIO::NetAccess::removeTempFile( m_info.localDestination );
        else
        {
            delete m_info.destinationKTempDir;
            m_info.destinationKTempDir = 0;
        }
        m_info.localDestination = "";
    }
}

void KomparePart::compare( const KUrl& source, const KUrl& destination )
{
    // FIXME: This is silly, i can use NetAccess::stat to figure out what it is and not
    // wait until i am in the modellist to determine the mode we're supposed to be in.
    // That should make the code more readable
    // I should store the KTempDir(s)/File(s) in the Info struct as well and delete it at the right time
    m_info.source = source;
    m_info.destination = destination;

    // FIXME: (Not urgent) But turn this into an enum, for now i cant find a nice name for the enum that has Source and Destination as values
    // For now we do not do error checking, user has already been notified and if the localString is empty then we dont diff
    fetchURL( source, true );
    fetchURL( destination, false );

    emit kompareInfo( &m_info );

    compareAndUpdateAll();
}

void KomparePart::compareFileString( const KUrl & sourceFile, const QString & destination)
{
    //Set the modeto specify that the source is a file, and the destination is a string
    m_info.mode = Kompare::ComparingFileString;
    
    m_info.source = sourceFile;
    m_info.localDestination = destination;
    
    fetchURL(sourceFile, true);
    
    emit kompareInfo( &m_info );
    
    compareAndUpdateAll();
}

void KomparePart::compareStringFile( const QString & source, const KUrl & destinationFile)
{
    //Set the modeto specify that the source is a file, and the destination is a string
    m_info.mode = Kompare::ComparingStringFile;
    
    m_info.localSource = source;
    m_info.destination = destinationFile;
    
    fetchURL(destinationFile, false);
    
    emit kompareInfo( &m_info );
    
    compareAndUpdateAll();
}

void KomparePart::compareFiles( const KUrl& sourceFile, const KUrl& destinationFile )
{
    m_info.mode = Kompare::ComparingFiles;

    m_info.source = sourceFile;
    m_info.destination = destinationFile;

    // FIXME: (Not urgent) But turn this into an enum, for now i cant find a nice name for the enum that has Source and Destination as values
    // For now we do not do error checking, user has already been notified and if the localString is empty then we dont diff
    fetchURL( sourceFile, true );
    fetchURL( destinationFile, false );

    emit kompareInfo( &m_info );

    compareAndUpdateAll();
}

void KomparePart::compareDirs( const KUrl& sourceDirectory, const KUrl& destinationDirectory )
{
    m_info.mode = Kompare::ComparingDirs;

    m_info.source = sourceDirectory;
    m_info.destination = destinationDirectory;

    fetchURL( sourceDirectory, true );
    fetchURL( destinationDirectory, false );

    emit kompareInfo( &m_info );

    compareAndUpdateAll();
}

void KomparePart::compare3Files( const KUrl& /*originalFile*/, const KUrl& /*changedFile1*/, const KUrl& /*changedFile2*/ )
{
    // FIXME: actually implement this some day :)
    updateActions();
    updateCaption();
    updateStatus();
}

void KomparePart::openFileAndDiff( const KUrl& file, const KUrl& diffFile )
{
    m_info.source = file;
    m_info.destination = diffFile;

    fetchURL( file, true );
    fetchURL( diffFile, false );
    m_info.mode = Kompare::BlendingFile;

    emit kompareInfo( &m_info );

    compareAndUpdateAll();
}

void KomparePart::openDirAndDiff ( const KUrl& dir,  const KUrl& diffFile )
{
    m_info.source = dir;
    m_info.destination = diffFile;

    fetchURL( dir, true );
    fetchURL( diffFile, false );
    m_info.mode = Kompare::BlendingDir;

    emit kompareInfo( &m_info );

    if ( !m_info.localSource.isEmpty() && !m_info.localDestination.isEmpty() )
    {
        m_modelList->openDirAndDiff();
        //Must this be in here? couldn't we use compareAndUpdateAll as well?
        updateActions();
        updateCaption();
        updateStatus();
    }
}

bool KomparePart::openFile()
{
    // This is called from openURL
    // This is a little inefficient but i will do it anyway
    openDiff( url() );
    return true;
}

bool KomparePart::saveAll()
{
    bool result = m_modelList->saveAll();
    updateActions();
    updateCaption();
    updateStatus();
    return result;
}

void KomparePart::saveDiff()
{
    KDialog dlg( widget() );
    dlg.setObjectName( "save_options" );
    dlg.setModal( true );
    dlg.setWindowTitle( i18n("Diff Options") );
    dlg.setButtons( KDialog::Ok|KDialog::Cancel );
    KompareSaveOptionsWidget* w = new KompareSaveOptionsWidget(
                                                 m_info.localSource,
                                                 m_info.localDestination,
                                                 m_diffSettings, &dlg );
    dlg.setMainWidget( w );
    dlg.setButtonGuiItem( KDialog::Ok, KStandardGuiItem::save() );

    if( dlg.exec() ) {
        w->saveOptions();
        KSharedConfig::Ptr config = componentData().config();
        saveProperties( config.data() );
        config->sync();

        while ( 1 )
        {
            KUrl url = KFileDialog::getSaveUrl( m_info.destination.url(),
                          i18n("*.diff *.dif *.patch|Patch Files"), widget(), i18n( "Save .diff" ) );
            if ( KIO::NetAccess::exists( url, KIO::NetAccess::DestinationSide, widget() ) )
            {
                int result = KMessageBox::warningYesNoCancel( widget(), i18n("The file exists or is write-protected; do you want to overwrite it?"), i18n("File Exists"), KGuiItem(i18n("Overwrite")), KGuiItem(i18n("Do Not Overwrite")) );
                if ( result == KMessageBox::Cancel )
                {
                    break;
                }
                else if ( result == KMessageBox::No )
                {
                    continue;
                }
                else
                {
                    kDebug(8103) << "URL = " << url.prettyUrl() << endl;
                    kDebug(8103) << "Directory = " << w->directory() << endl;
                    kDebug(8103) << "DiffSettings = " << m_diffSettings << endl;

                    m_modelList->saveDiff( url.url(), w->directory(), m_diffSettings );
                    break;
                }
            }
            else
            {
                kDebug(8103) << "URL = " << url.prettyUrl() << endl;
                kDebug(8103) << "Directory = " << w->directory() << endl;
                kDebug(8103) << "DiffSettings = " << m_diffSettings << endl;

                m_modelList->saveDiff( url.url(), w->directory(), m_diffSettings );
                break;
            }
        }
    }
}

void KomparePart::slotFilePrint()
{
    QPrinter printer;
    printer.setOrientation( QPrinter::Landscape );
    QPrintDialog* dlg = KdePrint::createPrintDialog( &printer, m_splitter );

    if ( dlg->exec() == QDialog::Accepted )
    {
        // do some printing in qprinter
        slotPaintRequested( &printer );
    }

    delete dlg;
}

void KomparePart::slotFilePrintPreview()
{
    QPrinter printer;
    printer.setOrientation( QPrinter::Landscape );
    QPrintPreviewDialog dlg( &printer );

    connect( &dlg, SIGNAL(paintRequested(QPrinter*)), this, SLOT(slotPaintRequested(QPrinter*)) );

    dlg.exec();
}

void KomparePart::slotPaintRequested( QPrinter* printer )
{
    kDebug(8103) << "Now paint something..." << endl;
    QPainter p;
    p.begin( printer );

    QSize widgetWidth = m_view->size();
    kDebug(8103) << "printer.width()     = " << printer->width() << endl;
    kDebug(8103) << "widgetWidth.width() = " << widgetWidth.width() << endl;
    qreal factor = ((qreal)printer->width())/((qreal)widgetWidth.width());

    kDebug(8103) << "factor              = " << factor << endl;

    p.scale( factor, factor );
    m_view->render( &p );

    p.end();
    kDebug(8103) << "Done painting something..." << endl;
}

KAboutData* KomparePart::createAboutData()
{
    KAboutData *about = new KAboutData("kompare", 0, ki18n("KomparePart"), "4.0");
    about->addAuthor(ki18n("John Firebaugh"), ki18n("Author"), "jfirebaugh@kde.org");
    about->addAuthor(ki18n("Otto Bruggeman"), ki18n("Author"), "bruggie@gmail.com" );
    about->addAuthor(ki18n("Kevin Kofler"), ki18n("Author"), "kevin.kofler@chello.at" );
    return about;
}

void KomparePart::slotSetStatus( enum Kompare::Status status )
{
    updateActions();

    switch( status ) {
    case Kompare::RunningDiff:
        emit setStatusBarText( i18n( "Running diff..." ) );
        break;
    case Kompare::Parsing:
        emit setStatusBarText( i18n( "Parsing diff output..." ) );
        break;
    case Kompare::FinishedParsing:
        updateStatus();
        break;
    case Kompare::FinishedWritingDiff:
        updateStatus();
        emit diffURLChanged();
        break;
    default:
        break;
    }
}

void KomparePart::updateCaption()
{
    QString source = m_info.source.prettyUrl();
    QString destination = m_info.destination.prettyUrl();

    QString text;

    switch ( m_info.mode )
    {
    case Kompare::ComparingFiles :
    case Kompare::ComparingDirs :
    case Kompare::BlendingFile :
    case Kompare::BlendingDir :
        text = source + " -- " + destination; // no need to translate this " -- "
        break;
    case Kompare::ShowingDiff :
        text = source;
        break;
    default:
        break;
    }

    emit setWindowCaption( text );
}

void KomparePart::updateStatus()
{
    QString source = m_info.source.prettyUrl();
    QString destination = m_info.destination.prettyUrl();

    QString text;

    switch ( m_info.mode )
    {
    case Kompare::ComparingFiles :
        text = i18n( "Comparing file %1 with file %2" ,
             source ,
             destination );
        break;
    case Kompare::ComparingDirs :
        text = i18n( "Comparing files in %1 with files in %2" ,
             source ,
             destination );
        break;
    case Kompare::ShowingDiff :
        text = i18n( "Viewing diff output from %1", source );
        break;
    case Kompare::BlendingFile :
        text = i18n( "Blending diff output from %1 into file %2" ,
              source ,
              destination );
        break;
    case Kompare::BlendingDir :
        text = i18n( "Blending diff output from %1 into folder %2" ,
              m_info.source.prettyUrl() ,
              m_info.destination.prettyUrl() );
        break;
    default:
        break;
    }

    emit setStatusBarText( text );
}

void KomparePart::compareAndUpdateAll()
{
    if ( !m_info.localSource.isEmpty() && !m_info.localDestination.isEmpty() )
    {
        switch(m_info.mode)
        {
        default:
        case Kompare::UnknownMode:
            m_modelList->compare();
            break;
        
        case Kompare::ComparingStringFile:
        case Kompare::ComparingFileString:
        case Kompare::ComparingFiles:
        case Kompare::ComparingDirs:
            m_modelList->compare(m_info.mode);
            break;
            
        case Kompare::BlendingFile:
            m_modelList->openFileAndDiff();
            break;
        }
        updateCaption();
        updateStatus();
    }
    updateActions();
}

void KomparePart::slotShowError( QString error )
{
    KMessageBox::error( widget(), error );
}

void KomparePart::slotSwap()
{
    if ( m_modelList->hasUnsavedChanges() )
    {
        int query = KMessageBox::warningYesNoCancel
                    (
                        widget(),
                        i18n( "You have made changes to the destination file(s).\n"
                              "Would you like to save them?" ),
                        i18n(  "Save Changes?" ),
                        KStandardGuiItem::save(),
                        KStandardGuiItem::discard()
                    );

        if ( query == KMessageBox::Yes )
            m_modelList->saveAll();

        if ( query == KMessageBox::Cancel )
            return; // Abort prematurely so no swapping
    }

    // Swap the info in the Kompare::Info struct
    m_info.swapSourceWithDestination();

    // Update window caption and statusbar text
    updateCaption();
    updateStatus();

    m_modelList->swap();
}

void KomparePart::slotRefreshDiff()
{
    if ( m_modelList->hasUnsavedChanges() )
    {
        int query = KMessageBox::warningYesNoCancel
                    (
                        widget(),
                        i18n( "You have made changes to the destination file(s).\n"
                              "Would you like to save them?" ),
                        i18n(  "Save Changes?" ),
                        KStandardGuiItem::save(),
                        KStandardGuiItem::discard()
                    );

        if ( query == KMessageBox::Cancel )
            return; // Abort prematurely so no refreshing

        if ( query == KMessageBox::Yes )
            m_modelList->saveAll();
    }

    // For this to work properly you have to refetch the files from their (remote) locations
    cleanUpTemporaryFiles();
    fetchURL( m_info.source, true );
    fetchURL( m_info.destination, false );
    m_modelList->refresh();
}

void KomparePart::slotShowDiffstats( void )
{
    // Fetch all the args needed for komparestatsmessagebox
    // oldfile, newfile, diffformat, noofhunks, noofdiffs

    QString oldFile;
    QString newFile;
    QString diffFormat;
    int filesInDiff;
    int noOfHunks;
    int noOfDiffs;

    oldFile = m_modelList->selectedModel() ? m_modelList->selectedModel()->sourceFile()  : QString( "" );
    newFile = m_modelList->selectedModel() ? m_modelList->selectedModel()->destinationFile() : QString( "" );

    if ( m_modelList->selectedModel() )
    {
        switch( m_info.format ) {
        case Kompare::Unified :
            diffFormat = i18n( "Unified" );
            break;
        case Kompare::Context :
            diffFormat = i18n( "Context" );
            break;
        case Kompare::RCS :
            diffFormat = i18n( "RCS" );
            break;
        case Kompare::Ed :
            diffFormat = i18n( "Ed" );
            break;
        case Kompare::Normal :
            diffFormat = i18n( "Normal" );
            break;
        case Kompare::UnknownFormat :
        default:
            diffFormat = i18n( "Unknown" );
            break;
        }
    }
    else
    {
        diffFormat = "";
    }

    filesInDiff = m_modelList->modelCount();

    noOfHunks = m_modelList->selectedModel() ? m_modelList->selectedModel()->hunkCount() : 0;
    noOfDiffs = m_modelList->selectedModel() ? m_modelList->selectedModel()->differenceCount() : 0;

    if ( m_modelList->modelCount() == 0 ) { // no diff loaded yet
        KMessageBox::information( 0L, i18n(
            "No diff file, or no 2 files have been diffed. "
            "Therefore no stats are available."),
            i18n("Diff Statistics"), QString(), 0 );
    }
    else if ( m_modelList->modelCount() == 1 ) { // 1 file in diff, or 2 files compared
        KMessageBox::information( 0L, i18n(
            "Statistics:\n"
            "\n"
            "Old file: %1\n"
            "New file: %2\n"
            "\n"
            "Format: %3\n"
            "Number of hunks: %4\n"
            "Number of differences: %5",
             oldFile, newFile, diffFormat,
             noOfHunks, noOfDiffs),
            i18n("Diff Statistics"), QString(), 0 );
    } else { // more than 1 file in diff, or 2 directories compared
        KMessageBox::information( 0L, ki18n(
            "Statistics:\n"
            "\n"
            "Number of files in diff file: %1\n"
            "Format: %2\n"
            "\n"
            "Current old file: %3\n"
            "Current new file: %4\n"
            "\n"
            "Number of hunks: %5\n"
            "Number of differences: %6")
            .subs(filesInDiff).subs(diffFormat).subs(oldFile)
            .subs(newFile).subs(noOfHunks).subs(noOfDiffs)
                    .toString(),
            i18n("Diff Statistics"), QString(), 0 );
    }
}

bool KomparePart::queryClose()
{
    if ( !m_modelList->hasUnsavedChanges() ) return true;

    int query = KMessageBox::warningYesNoCancel
                (
                    widget(),
                    i18n("You have made changes to the destination file(s).\n"
                         "Would you like to save them?" ),
                    i18n( "Save Changes?" ),
                    KStandardGuiItem::save(),
                    KStandardGuiItem::discard()
                );

    if( query == KMessageBox::Cancel )
        return false;

    if( query == KMessageBox::Yes )
        return m_modelList->saveAll();

    return true;
}

int KomparePart::readProperties( KConfig *config )
{
    m_viewSettings->loadSettings( config );
    m_diffSettings->loadSettings( config );
    emit configChanged();
    return 0;
}

int KomparePart::saveProperties( KConfig *config )
{
    m_viewSettings->saveSettings( config );
    m_diffSettings->saveSettings( config );
    return 0;
}

void KomparePart::optionsPreferences()
{
    // show preferences
    KomparePrefDlg pref( m_viewSettings, m_diffSettings );

    connect( &pref, SIGNAL(configChanged()), this, SIGNAL(configChanged()) );

    if ( pref.exec() )
        emit configChanged();
}

#include "kompare_part.moc"