You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2892 lines
95 KiB
2892 lines
95 KiB
15 years ago
|
/***************************************************************************
|
||
|
* Copyright (C) 2005-2007 by Rajko Albrecht *
|
||
|
* ral@alwins-world.de *
|
||
|
* *
|
||
|
* 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. *
|
||
|
* *
|
||
|
* This program 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 General Public License for more details. *
|
||
|
* *
|
||
|
* You should have received a copy of the GNU General Public License *
|
||
|
* along with this program; if not, write to the *
|
||
|
* Free Software Foundation, Inc., *
|
||
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
|
||
|
***************************************************************************/
|
||
|
#include "svnactions.h"
|
||
|
#include "checkoutinfo_impl.h"
|
||
|
#include "itemdisplay.h"
|
||
|
#include "svnitem.h"
|
||
|
#include "rangeinput_impl.h"
|
||
|
#include "propertiesdlg.h"
|
||
|
#include "ccontextlistener.h"
|
||
|
#include "tcontextlistener.h"
|
||
|
#include "modifiedthread.h"
|
||
|
#include "fillcachethread.h"
|
||
|
#include "svnlogdlgimp.h"
|
||
|
#include "stopdlg.h"
|
||
|
#include "blamedisplay_impl.h"
|
||
|
#include "src/ksvnwidgets/logmsg_impl.h"
|
||
|
#include "src/ksvnwidgets/diffbrowser.h"
|
||
|
#include "src/ksvnwidgets/encodingselector_impl.h"
|
||
|
#include "src/ksvnwidgets/revertform_impl.h"
|
||
|
#include "graphtree/revisiontree.h"
|
||
|
#include "src/settings/kdesvnsettings.h"
|
||
|
#include "src/kdesvn_events.h"
|
||
|
#include "src/svnqt/client.hpp"
|
||
|
#include "src/svnqt/annotate_line.hpp"
|
||
|
#include "src/svnqt/context_listener.hpp"
|
||
|
#include "src/svnqt/dirent.hpp"
|
||
|
#include "src/svnqt/targets.hpp"
|
||
|
#include "src/svnqt/url.hpp"
|
||
|
#include "src/svnqt/wc.hpp"
|
||
|
#include "src/svnqt/svnqt_defines.hpp"
|
||
|
#include "src/svnqt/cache/LogCache.hpp"
|
||
|
#include "src/svnqt/cache/ReposLog.hpp"
|
||
|
#include "src/svnqt/url.hpp"
|
||
|
|
||
|
#include "helpers/sub2qt.h"
|
||
|
#include "fronthelpers/cursorstack.h"
|
||
|
#include "cacheentry.h"
|
||
|
|
||
|
#include <kdialog.h>
|
||
|
#include <ktextbrowser.h>
|
||
|
#include <klocale.h>
|
||
|
#include <kglobalsettings.h>
|
||
|
#include <kmessagebox.h>
|
||
|
#include <kinputdialog.h>
|
||
|
#include <kprocess.h>
|
||
|
#include <ktempdir.h>
|
||
|
#include <ktempfile.h>
|
||
|
#include <kdialogbase.h>
|
||
|
#include <kapplication.h>
|
||
|
#include <kio/jobclasses.h>
|
||
|
#include <kio/job.h>
|
||
|
#include <kdebug.h>
|
||
|
#include <kconfig.h>
|
||
|
#include <klistview.h>
|
||
|
#include <kio/netaccess.h>
|
||
|
#include <kstandarddirs.h>
|
||
|
#include <ktrader.h>
|
||
|
#include <krun.h>
|
||
|
#include <kstdguiitem.h>
|
||
|
|
||
|
#include <qstring.h>
|
||
|
#include <qmap.h>
|
||
|
#include <qpushbutton.h>
|
||
|
#include <qlayout.h>
|
||
|
#include <qvaluelist.h>
|
||
|
#include <qvbox.h>
|
||
|
#include <qstylesheet.h>
|
||
|
#include <qregexp.h>
|
||
|
#include <qimage.h>
|
||
|
#include <qthread.h>
|
||
|
#include <qtimer.h>
|
||
|
#include <qlistview.h>
|
||
|
#include <qfileinfo.h>
|
||
|
#include <sys/time.h>
|
||
|
#include <unistd.h>
|
||
|
#include <qguardedptr.h>
|
||
|
|
||
|
// wait not longer than 10 seconds for a thread
|
||
|
#define MAX_THREAD_WAITTIME 10000
|
||
|
|
||
|
class SvnActionsData:public svn::ref_count
|
||
|
{
|
||
|
typedef svn::SharedPointer<svn::PathPropertiesMapList> sPPlist;
|
||
|
public:
|
||
|
SvnActionsData():ref_count()
|
||
|
{
|
||
|
m_Svnclient = svn::Client::getobject(0,0);
|
||
|
m_CurrentContext = 0;
|
||
|
}
|
||
|
|
||
|
virtual ~SvnActionsData()
|
||
|
{
|
||
|
if (m_DiffDialog) {
|
||
|
m_DiffDialog->saveDialogSize(*(Kdesvnsettings::self()->config()),"diff_display",false);
|
||
|
delete m_DiffDialog;
|
||
|
}
|
||
|
if (m_LogDialog) {
|
||
|
m_LogDialog->saveSize();
|
||
|
delete m_LogDialog;
|
||
|
}
|
||
|
|
||
|
QMap<KProcess*,QStringList>::iterator it;
|
||
|
for (it=m_tempfilelist.begin();it!=m_tempfilelist.end();++it) {
|
||
|
for (QStringList::iterator it2 = (*it).begin();
|
||
|
it2 != (*it).end();++it2) {
|
||
|
::unlink((*it2).ascii());
|
||
|
}
|
||
|
}
|
||
|
for (it=m_tempdirlist.begin();it!=m_tempdirlist.end();++it) {
|
||
|
for (QStringList::iterator it2 = (*it).begin();
|
||
|
it2 != (*it).end();++it2) {
|
||
|
KIO::NetAccess::del((*it2),0);
|
||
|
}
|
||
|
}
|
||
|
delete m_Svnclient;
|
||
|
m_Svnclient = 0L;
|
||
|
}
|
||
|
|
||
|
bool isExternalDiff()
|
||
|
{
|
||
|
if (Kdesvnsettings::use_external_diff()) {
|
||
|
QString edisp = Kdesvnsettings::external_diff_display();
|
||
|
QStringList wlist = QStringList::split(" ",edisp);
|
||
|
if (wlist.count()>=3 && edisp.find("%1")!=-1 && edisp.find("%2")!=-1) {
|
||
|
return true;
|
||
|
}
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
void clearCaches()
|
||
|
{
|
||
|
m_PropertiesCache.clear();
|
||
|
m_contextData.clear();
|
||
|
m_InfoCache.clear();
|
||
|
}
|
||
|
|
||
|
void cleanDialogs()
|
||
|
{
|
||
|
if (m_DiffDialog) {
|
||
|
m_DiffDialog->saveDialogSize(*(Kdesvnsettings::self()->config()),"diff_display",false);
|
||
|
delete m_DiffDialog;
|
||
|
m_DiffDialog=0;
|
||
|
}
|
||
|
if (m_LogDialog) {
|
||
|
m_LogDialog->saveSize();
|
||
|
delete m_LogDialog;
|
||
|
m_LogDialog=0;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
ItemDisplay* m_ParentList;
|
||
|
|
||
|
svn::smart_pointer<CContextListener> m_SvnContextListener;
|
||
|
svn::ContextP m_CurrentContext;
|
||
|
svn::Client*m_Svnclient;
|
||
|
|
||
|
helpers::statusCache m_UpdateCache;
|
||
|
helpers::statusCache m_Cache;
|
||
|
helpers::statusCache m_conflictCache;
|
||
|
helpers::statusCache m_repoLockCache;
|
||
|
helpers::itemCache<svn::PathPropertiesMapListPtr> m_PropertiesCache;
|
||
|
/// \todo as persistent cache (sqlite?)
|
||
|
helpers::itemCache<svn::InfoEntry> m_InfoCache;
|
||
|
|
||
|
QMap<KProcess*,QStringList> m_tempfilelist;
|
||
|
QMap<KProcess*,QStringList> m_tempdirlist;
|
||
|
|
||
|
QTimer m_ThreadCheckTimer;
|
||
|
QTimer m_UpdateCheckTimer;
|
||
|
QTime m_UpdateCheckTick;
|
||
|
QGuardedPtr<DiffBrowser> m_DiffBrowserPtr;
|
||
|
QGuardedPtr<KDialogBase> m_DiffDialog;
|
||
|
QGuardedPtr<SvnLogDlgImp> m_LogDialog;
|
||
|
|
||
|
QMap<QString,QString> m_contextData;
|
||
|
|
||
|
bool runblocked;
|
||
|
};
|
||
|
|
||
|
#define EMIT_FINISHED emit sendNotify(i18n("Finished"))
|
||
|
#define EMIT_REFRESH emit sigRefreshAll()
|
||
|
#define DIALOGS_SIZES "display_dialogs_sizes"
|
||
|
|
||
|
SvnActions::SvnActions(ItemDisplay *parent, const char *name,bool processes_blocked)
|
||
|
: QObject(parent?parent->realWidget():0, name),SimpleLogCb()
|
||
|
{
|
||
|
m_CThread = 0;
|
||
|
m_UThread = 0;
|
||
|
m_FCThread = 0;
|
||
|
m_Data = new SvnActionsData();
|
||
|
m_Data->m_ParentList = parent;
|
||
|
m_Data->m_SvnContextListener = new CContextListener(this);
|
||
|
m_Data->runblocked = processes_blocked;
|
||
|
connect(m_Data->m_SvnContextListener,SIGNAL(sendNotify(const QString&)),this,SLOT(slotNotifyMessage(const QString&)));
|
||
|
connect(&(m_Data->m_ThreadCheckTimer),SIGNAL(timeout()),this,SLOT(checkModthread()));
|
||
|
connect(&(m_Data->m_UpdateCheckTimer),SIGNAL(timeout()),this,SLOT(checkUpdateThread()));
|
||
|
}
|
||
|
|
||
|
svn::Client* SvnActions::svnclient()
|
||
|
{
|
||
|
return m_Data->m_Svnclient;
|
||
|
}
|
||
|
|
||
|
SvnActions::~SvnActions()
|
||
|
{
|
||
|
killallThreads();
|
||
|
}
|
||
|
|
||
|
void SvnActions::slotNotifyMessage(const QString&aMsg)
|
||
|
{
|
||
|
emit sendNotify(aMsg);
|
||
|
}
|
||
|
|
||
|
void SvnActions::reInitClient()
|
||
|
{
|
||
|
m_Data->clearCaches();
|
||
|
m_Data->cleanDialogs();
|
||
|
if (m_Data->m_CurrentContext) m_Data->m_CurrentContext->setListener(0L);
|
||
|
m_Data->m_CurrentContext = new svn::Context();
|
||
|
m_Data->m_CurrentContext->setListener(m_Data->m_SvnContextListener);
|
||
|
m_Data->m_Svnclient->setContext(m_Data->m_CurrentContext);
|
||
|
}
|
||
|
|
||
|
template<class T> KDialogBase* SvnActions::createDialog(T**ptr,const QString&_head,bool OkCancel,const char*name,bool showHelp,bool modal,const KGuiItem&u1)
|
||
|
{
|
||
|
int buttons = KDialogBase::Ok;
|
||
|
if (OkCancel) {
|
||
|
buttons = buttons|KDialogBase::Cancel;
|
||
|
}
|
||
|
if (showHelp) {
|
||
|
buttons = buttons|KDialogBase::Help;
|
||
|
}
|
||
|
if (!u1.text().isEmpty()) {
|
||
|
buttons = buttons|KDialogBase::User1;
|
||
|
}
|
||
|
KDialogBase * dlg = new KDialogBase(
|
||
|
modal?KApplication::activeModalWidget():0, // parent
|
||
|
name, // name
|
||
|
modal, // modal
|
||
|
_head, // caption
|
||
|
buttons, // buttonmask
|
||
|
KDialogBase::Ok, // defaultButton
|
||
|
false , // separator
|
||
|
(u1.text().isEmpty()?KGuiItem():u1) //user1
|
||
|
);
|
||
|
|
||
|
if (!dlg) return dlg;
|
||
|
QWidget* Dialog1Layout = dlg->makeVBoxMainWidget();
|
||
|
*ptr = new T(Dialog1Layout);
|
||
|
dlg->resize(dlg->configDialogSize(*(Kdesvnsettings::self()->config()),name?name:DIALOGS_SIZES));
|
||
|
return dlg;
|
||
|
}
|
||
|
|
||
|
/*!
|
||
|
\fn SvnActions::makeLog(svn::Revision start,svn::Revision end,FileListViewItem*k)
|
||
|
*/
|
||
|
void SvnActions::makeLog(const svn::Revision&start,const svn::Revision&end,const svn::Revision&peg,SvnItem*k,bool list_files,int limit)
|
||
|
{
|
||
|
if (k) {
|
||
|
makeLog(start,end,peg,k->fullName(),list_files,limit);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
svn::SharedPointer<svn::LogEntriesMap> SvnActions::getLog(const svn::Revision&start,const svn::Revision&end,const svn::Revision&peg,const QString&which,bool list_files,
|
||
|
int limit,QWidget*parent)
|
||
|
{
|
||
|
svn::SharedPointer<svn::LogEntriesMap> logs = new svn::LogEntriesMap;
|
||
|
if (!m_Data->m_CurrentContext) return 0;
|
||
|
|
||
|
bool follow = Kdesvnsettings::log_follows_nodes();
|
||
|
|
||
|
kdDebug()<<"Get logs for "<< which<<endl;
|
||
|
try {
|
||
|
StopDlg sdlg(m_Data->m_SvnContextListener,(parent?parent:m_Data->m_ParentList->realWidget()),0,"Logs",
|
||
|
i18n("Getting logs - hit cancel for abort"));
|
||
|
connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
|
||
|
if (doNetworking()) {
|
||
|
m_Data->m_Svnclient->log(which,start,end,*logs,peg,list_files,!follow,limit);
|
||
|
} else {
|
||
|
svn::InfoEntry e;
|
||
|
if (!singleInfo(m_Data->m_ParentList->baseUri(),svn::Revision::BASE,e)) {
|
||
|
return 0;
|
||
|
}
|
||
|
if (svn::Url::isLocal(e.reposRoot())) {
|
||
|
m_Data->m_Svnclient->log(which,start,end,*logs,peg,list_files,!follow,limit);
|
||
|
} else {
|
||
|
svn::cache::ReposLog rl(m_Data->m_Svnclient,e.reposRoot());
|
||
|
QString s1,s2,what;
|
||
|
s1=e.url().mid(e.reposRoot().length());
|
||
|
if (which==".") {
|
||
|
what=s1;
|
||
|
} else {
|
||
|
s2=which.mid(m_Data->m_ParentList->baseUri().length());
|
||
|
what=s1+"/"+s2;
|
||
|
}
|
||
|
rl.log(what,start,end,peg,*logs,!follow,limit);
|
||
|
}
|
||
|
}
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return 0;
|
||
|
}
|
||
|
if (!logs) {
|
||
|
emit clientException(i18n("Got no logs"));
|
||
|
return 0;
|
||
|
}
|
||
|
return logs;
|
||
|
}
|
||
|
|
||
|
bool SvnActions::getSingleLog(svn::LogEntry&t,const svn::Revision&r,const QString&what,const svn::Revision&peg,QString&root)
|
||
|
{
|
||
|
bool res = false;
|
||
|
|
||
|
if (what.isEmpty()) {
|
||
|
return res;
|
||
|
}
|
||
|
if (root.isEmpty()) {
|
||
|
svn::InfoEntry inf;
|
||
|
if (!singleInfo(what,peg,inf))
|
||
|
{
|
||
|
return res;
|
||
|
}
|
||
|
root = inf.reposRoot();
|
||
|
}
|
||
|
|
||
|
if (!svn::Url::isLocal(root)) {
|
||
|
svn::LogEntriesMap _m;
|
||
|
try {
|
||
|
svn::cache::ReposLog rl(m_Data->m_Svnclient ,root);
|
||
|
if (rl.isValid() && rl.simpleLog(_m,r,r,true) && _m.find(r.revnum())!=_m.end() ) {
|
||
|
t = _m[r.revnum()];
|
||
|
res = true;
|
||
|
}
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (!res) {
|
||
|
svn::SharedPointer<svn::LogEntriesMap> log = getLog(r,r,peg,root,true,1);
|
||
|
if (log) {
|
||
|
if (log->find(r.revnum())!=log->end()) {
|
||
|
t = (*log)[r.revnum()];
|
||
|
res = true;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
return res;
|
||
|
}
|
||
|
|
||
|
bool SvnActions::singleInfo(const QString&what,const svn::Revision&_rev,svn::InfoEntry&target,const svn::Revision&_peg)
|
||
|
{
|
||
|
QString url;
|
||
|
QString ex;
|
||
|
QString cacheKey;
|
||
|
QTime d; d.start();
|
||
|
svn::Revision rev = _rev;
|
||
|
svn::Revision peg = _peg;
|
||
|
if (!m_Data->m_CurrentContext) return false;
|
||
|
if (!svn::Url::isValid(what)) {
|
||
|
// working copy
|
||
|
// url = svn::Wc::getUrl(what);
|
||
|
url = what;
|
||
|
if (url.find("@")!=-1) {
|
||
|
url+="@BASE";
|
||
|
}
|
||
|
peg = svn::Revision::UNDEFINED;
|
||
|
cacheKey=url;
|
||
|
} else {
|
||
|
KURL _uri = what;
|
||
|
QString prot = svn::Url::transformProtokoll(_uri.protocol());
|
||
|
_uri.setProtocol(prot);
|
||
|
url = _uri.prettyURL();
|
||
|
if (peg==svn::Revision::UNDEFINED)
|
||
|
{
|
||
|
peg = _rev;
|
||
|
}
|
||
|
if (peg==svn::Revision::UNDEFINED)
|
||
|
{
|
||
|
peg=svn::Revision::HEAD;
|
||
|
}
|
||
|
cacheKey=_rev.toString()+"/"+url;
|
||
|
}
|
||
|
svn::InfoEntries e;
|
||
|
|
||
|
if (cacheKey.isEmpty() || !m_Data->m_InfoCache.findSingleValid(cacheKey,target)) {
|
||
|
try {
|
||
|
e = (m_Data->m_Svnclient->info(url,svn::DepthEmpty,_rev,peg));
|
||
|
} catch (const svn::Exception&ce) {
|
||
|
kdDebug()<<"Singleinfo: "<<_rev.toString()<<endl;
|
||
|
kdDebug()<<"Singleinfo: "<<ce.msg() << endl;
|
||
|
emit clientException(ce.msg());
|
||
|
return false;
|
||
|
}
|
||
|
if (e.count()<1||e[0].reposRoot().isEmpty()) {
|
||
|
emit clientException(i18n("Got no info."));
|
||
|
return false;
|
||
|
}
|
||
|
target = e[0];
|
||
|
if (!cacheKey.isEmpty()) {
|
||
|
m_Data->m_InfoCache.insertKey(e[0],cacheKey);
|
||
|
if (peg != svn::Revision::UNDEFINED && peg.kind()!= svn::Revision::NUMBER && peg.kind()!= svn::Revision::DATE ) {
|
||
|
// for persistent storage, store head into persistent cache makes no sense.
|
||
|
cacheKey=e[0].revision().toString()+"/"+url;
|
||
|
kdDebug()<<"Extra: "<<cacheKey<<endl;
|
||
|
m_Data->m_InfoCache.insertKey(e[0],cacheKey);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
void SvnActions::makeTree(const QString&what,const svn::Revision&_rev,const svn::Revision&startr,const svn::Revision&endr)
|
||
|
{
|
||
|
svn::InfoEntry info;
|
||
|
if (!singleInfo(what,_rev,info)) {
|
||
|
return;
|
||
|
}
|
||
|
QString reposRoot = info.reposRoot();
|
||
|
|
||
|
bool restartCache = (m_FCThread && m_FCThread->running());
|
||
|
if (restartCache) {
|
||
|
stopFillCache();
|
||
|
}
|
||
|
kdDebug()<<"Logs for "<<reposRoot<<endl;
|
||
|
QWidget*disp;
|
||
|
KDialogBase dlg(m_Data->m_ParentList->realWidget(),"historylist",true,i18n("History of %1").arg(info.url().mid(reposRoot.length())),
|
||
|
KDialogBase::Ok,
|
||
|
KDialogBase::Ok,true);
|
||
|
QWidget* Dialog1Layout = dlg.makeVBoxMainWidget();
|
||
|
|
||
|
RevisionTree rt(m_Data->m_Svnclient,m_Data->m_SvnContextListener,reposRoot,
|
||
|
startr,endr,
|
||
|
info.prettyUrl().mid(reposRoot.length()),_rev,Dialog1Layout,m_Data->m_ParentList->realWidget());
|
||
|
if (rt.isValid()) {
|
||
|
disp = rt.getView();
|
||
|
if (disp) {
|
||
|
connect(
|
||
|
disp,SIGNAL(makeNorecDiff(const QString&,const svn::Revision&,const QString&,const svn::Revision&,QWidget*)),
|
||
|
this,SLOT(makeNorecDiff(const QString&,const svn::Revision&,const QString&,const svn::Revision&,QWidget*))
|
||
|
);
|
||
|
connect(
|
||
|
disp,SIGNAL(makeRecDiff(const QString&,const svn::Revision&,const QString&,const svn::Revision&,QWidget*)),
|
||
|
this,SLOT(makeDiff(const QString&,const svn::Revision&,const QString&,const svn::Revision&,QWidget*))
|
||
|
);
|
||
|
connect(disp,SIGNAL(makeCat(const svn::Revision&, const QString&,const QString&,const svn::Revision&,QWidget*)),
|
||
|
this,SLOT(slotMakeCat(const svn::Revision&,const QString&,const QString&,const svn::Revision&,QWidget*)));
|
||
|
dlg.resize(dlg.configDialogSize(*(Kdesvnsettings::self()->config()),"revisiontree_dlg"));
|
||
|
dlg.exec();
|
||
|
dlg.saveDialogSize(*(Kdesvnsettings::self()->config()),"revisiontree_dlg",false);
|
||
|
}
|
||
|
}
|
||
|
if (restartCache) {
|
||
|
startFillCache(reposRoot);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void SvnActions::makeLog(const svn::Revision&start,const svn::Revision&end,const svn::Revision&peg,const QString&which,bool list_files,int limit)
|
||
|
{
|
||
|
svn::InfoEntry info;
|
||
|
if (!singleInfo(which,start,info)) {
|
||
|
return;
|
||
|
}
|
||
|
QString reposRoot = info.reposRoot();
|
||
|
kdDebug()<<"getting logs..."<<endl;
|
||
|
svn::SharedPointer<svn::LogEntriesMap> logs = getLog(start,end,peg,which,list_files,limit);
|
||
|
if (!logs) return;
|
||
|
bool need_modal = m_Data->runblocked||KApplication::activeModalWidget()!=0;
|
||
|
if (need_modal||!m_Data->m_LogDialog) {
|
||
|
m_Data->m_LogDialog=new SvnLogDlgImp(this,0,"logdialog",need_modal);
|
||
|
connect(m_Data->m_LogDialog,SIGNAL(makeDiff(const QString&,const svn::Revision&,const QString&,const svn::Revision&,QWidget*)),
|
||
|
this,SLOT(makeDiff(const QString&,const svn::Revision&,const QString&,const svn::Revision&,QWidget*)));
|
||
|
connect(m_Data->m_LogDialog,SIGNAL(makeCat(const svn::Revision&, const QString&,const QString&,const svn::Revision&,QWidget*)),
|
||
|
this,SLOT(slotMakeCat(const svn::Revision&,const QString&,const QString&,const svn::Revision&,QWidget*)));
|
||
|
}
|
||
|
|
||
|
if (m_Data->m_LogDialog) {
|
||
|
m_Data->m_LogDialog->dispLog(logs,info.url().mid(reposRoot.length()),reposRoot,
|
||
|
(
|
||
|
peg==svn::Revision::UNDEFINED?
|
||
|
(svn::Url::isValid(which)?svn::Revision::HEAD:svn::Revision::UNDEFINED):
|
||
|
peg
|
||
|
),which);
|
||
|
if (need_modal) {
|
||
|
m_Data->m_LogDialog->exec();
|
||
|
m_Data->m_LogDialog->saveSize();
|
||
|
delete m_Data->m_LogDialog;
|
||
|
} else {
|
||
|
m_Data->m_LogDialog->show();
|
||
|
m_Data->m_LogDialog->raise();
|
||
|
}
|
||
|
}
|
||
|
EMIT_FINISHED;
|
||
|
}
|
||
|
|
||
|
void SvnActions::makeBlame(const svn::Revision&start, const svn::Revision&end, SvnItem*k)
|
||
|
{
|
||
|
if (k) makeBlame(start,end,k->fullName(),m_Data->m_ParentList->realWidget());
|
||
|
}
|
||
|
|
||
|
void SvnActions::makeBlame(const svn::Revision&start, const svn::Revision&end,const QString&k,QWidget*_p,const svn::Revision&_peg,SimpleLogCb*_acb)
|
||
|
{
|
||
|
if (!m_Data->m_CurrentContext) return;
|
||
|
svn::AnnotatedFile blame;
|
||
|
QString ex;
|
||
|
svn::Path p(k);
|
||
|
QWidget*_parent = _p?_p:m_Data->m_ParentList->realWidget();
|
||
|
svn::Revision peg = _peg==svn::Revision::UNDEFINED?end:_peg;
|
||
|
|
||
|
try {
|
||
|
CursorStack a(Qt::BusyCursor);
|
||
|
StopDlg sdlg(m_Data->m_SvnContextListener,_parent,0,"Annotate",i18n("Annotate lines - hit cancel for abort"));
|
||
|
connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
|
||
|
m_Data->m_Svnclient->annotate(blame,p,start,end,peg);
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return;
|
||
|
}
|
||
|
if (blame.count()==0) {
|
||
|
ex = i18n("Got no annotate");
|
||
|
emit clientException(ex);
|
||
|
return;
|
||
|
}
|
||
|
EMIT_FINISHED;
|
||
|
BlameDisplay_impl::displayBlame(_acb?_acb:this,k,blame,_p,"blame_dlg");
|
||
|
}
|
||
|
|
||
|
bool SvnActions::makeGet(const svn::Revision&start, const QString&what, const QString&target,
|
||
|
const svn::Revision&peg,QWidget*_dlgparent)
|
||
|
{
|
||
|
if (!m_Data->m_CurrentContext) return false;
|
||
|
CursorStack a(Qt::BusyCursor);
|
||
|
QWidget*dlgp=_dlgparent?_dlgparent:m_Data->m_ParentList->realWidget();
|
||
|
QString ex;
|
||
|
svn::Path p(what);
|
||
|
try {
|
||
|
StopDlg sdlg(m_Data->m_SvnContextListener,dlgp,
|
||
|
0,"Content get",i18n("Getting content - hit cancel for abort"));
|
||
|
connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
|
||
|
m_Data->m_Svnclient->get(p,target,start,peg);
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return false;
|
||
|
} catch (...) {
|
||
|
ex = i18n("Error getting content");
|
||
|
emit clientException(ex);
|
||
|
return false;
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
void SvnActions::slotMakeCat(const svn::Revision&start, const QString&what, const QString&disp,const svn::Revision&peg,QWidget*_dlgparent)
|
||
|
{
|
||
|
KTempFile content;
|
||
|
content.setAutoDelete(true);
|
||
|
if (!makeGet(start,what,content.name(),peg,_dlgparent)) {
|
||
|
return;
|
||
|
}
|
||
|
EMIT_FINISHED;
|
||
|
KMimeType::Ptr mptr;
|
||
|
mptr = KMimeType::findByFileContent(content.name());
|
||
|
KTrader::OfferList offers = KTrader::self()->query(mptr->name(), "Type == 'Application' or (exist Exec)");
|
||
|
if (offers.count()==0 || offers.first()->exec().isEmpty()) {
|
||
|
offers = KTrader::self()->query(mptr->name(), "Type == 'Application'");
|
||
|
}
|
||
|
KTrader::OfferList::ConstIterator it = offers.begin();
|
||
|
for( ; it != offers.end(); ++it ) {
|
||
|
if ((*it)->noDisplay())
|
||
|
continue;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
if (it!=offers.end()) {
|
||
|
content.setAutoDelete(false);
|
||
|
KRun::run(**it,KURL(content.name()),true);
|
||
|
return;
|
||
|
}
|
||
|
KTextBrowser*ptr;
|
||
|
QFile file(content.name());
|
||
|
file.open( IO_ReadOnly );
|
||
|
QByteArray co = file.readAll();
|
||
|
|
||
|
if (co.size()) {
|
||
|
KDialogBase*dlg = createDialog(&ptr,QString(i18n("Content of %1")).arg(disp),false,"cat_display_dlg");
|
||
|
if (dlg) {
|
||
|
ptr->setFont(KGlobalSettings::fixedFont());
|
||
|
ptr->setWordWrap(QTextEdit::NoWrap);
|
||
|
ptr->setText(QString::FROMUTF8(co,co.size()));
|
||
|
dlg->exec();
|
||
|
dlg->saveDialogSize(*(Kdesvnsettings::self()->config()),"cat_display_dlg",false);
|
||
|
delete dlg;
|
||
|
}
|
||
|
} else {
|
||
|
KMessageBox::information(_dlgparent?_dlgparent:m_Data->m_ParentList->realWidget(),
|
||
|
i18n("Got no content."));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
bool SvnActions::makeMkdir(const QStringList&which,const QString&logMessage)
|
||
|
{
|
||
|
if (!m_Data->m_CurrentContext||which.count()<1) return false;
|
||
|
svn::Targets targets(which);
|
||
|
try {
|
||
|
m_Data->m_Svnclient->mkdir(targets,logMessage);
|
||
|
}catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return false;
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
QString SvnActions::makeMkdir(const QString&parentDir)
|
||
|
{
|
||
|
if (!m_Data->m_CurrentContext) return QString::null;
|
||
|
QString ex;
|
||
|
bool isOk=false;
|
||
|
ex = KInputDialog::getText(i18n("New folder"),i18n("Enter folder name:"),QString::null,&isOk);
|
||
|
if (!isOk) {
|
||
|
return QString::null;
|
||
|
}
|
||
|
svn::Path target(parentDir);
|
||
|
target.addComponent(ex);
|
||
|
ex = "";
|
||
|
|
||
|
QString logMessage=QString::null;
|
||
|
try {
|
||
|
m_Data->m_Svnclient->mkdir(target,logMessage);
|
||
|
}catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return QString::null;
|
||
|
}
|
||
|
|
||
|
ex = target.path();
|
||
|
return ex;
|
||
|
}
|
||
|
|
||
|
QString SvnActions::getInfo(QPtrList<SvnItem> lst,const svn::Revision&rev,const svn::Revision&peg,bool recursive,bool all)
|
||
|
{
|
||
|
QStringList l;
|
||
|
QString res = "";
|
||
|
SvnItem*item;
|
||
|
for (item=lst.first();item;item=lst.next()) {
|
||
|
if (all) res+="<h4 align=\"center\">"+item->fullName()+"</h4>";
|
||
|
res += getInfo(item->fullName(),rev,peg,recursive,all);
|
||
|
}
|
||
|
return res;
|
||
|
}
|
||
|
|
||
|
QString SvnActions::getInfo(const QString& _what,const svn::Revision&rev,const svn::Revision&peg,bool recursive,bool all)
|
||
|
{
|
||
|
if (!m_Data->m_CurrentContext) return QString::null;
|
||
|
QString ex;
|
||
|
svn::InfoEntries entries;
|
||
|
if (recursive) {
|
||
|
try {
|
||
|
StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,"Details",
|
||
|
i18n("Retrieving infos - hit cancel for abort"));
|
||
|
connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
|
||
|
svn::InfoEntries e;
|
||
|
entries = (m_Data->m_Svnclient->info(_what+
|
||
|
(_what.find("@")>-1&&!svn::Url::isValid(_what)?"@BASE":""),recursive?svn::DepthInfinity:svn::DepthEmpty,rev,peg));
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return QString::null;
|
||
|
}
|
||
|
} else {
|
||
|
svn::InfoEntry info;
|
||
|
if (!singleInfo(_what,rev,info,peg)) {
|
||
|
return QString::null;
|
||
|
}
|
||
|
entries.append(info);
|
||
|
}
|
||
|
//if (!all) EMIT_FINISHED;
|
||
|
QString text = "";
|
||
|
svn::InfoEntries::const_iterator it;
|
||
|
static QString rb = "<tr><td><nobr><font color=\"black\">";
|
||
|
static QString re = "</font></nobr></td></tr>\n";
|
||
|
static QString cs = "</font></nobr>:</td><td><nobr><font color=\"black\">";
|
||
|
unsigned int val = 0;
|
||
|
for (it=entries.begin();it!=entries.end();++it) {
|
||
|
if (val>0) {
|
||
|
text+="<hline>";
|
||
|
}
|
||
|
text+="<p align=\"center\">";
|
||
|
text+="<table cellspacing=0 cellpadding=0>";
|
||
|
if ((*it).Name().length()) {
|
||
|
text+=rb+i18n("Name")+cs+((*it).Name())+re;
|
||
|
}
|
||
|
if (all) {
|
||
|
text+=rb+i18n("URL")+cs+((*it).url())+re;
|
||
|
if ((*it).reposRoot().length()) {
|
||
|
text+=rb+i18n("Canonical repository url")+cs+((*it).reposRoot())+re;
|
||
|
}
|
||
|
if ((*it).checksum().length()) {
|
||
|
text+=rb+i18n("Checksum")+cs+((*it).checksum())+re;
|
||
|
}
|
||
|
}
|
||
|
text+=rb+i18n("Type")+cs;
|
||
|
switch ((*it).kind()) {
|
||
|
case svn_node_none:
|
||
|
text+=i18n("Absent");
|
||
|
break;
|
||
|
case svn_node_file:
|
||
|
text+=i18n("File");
|
||
|
break;
|
||
|
case svn_node_dir:
|
||
|
text+=i18n("Folder");
|
||
|
break;
|
||
|
case svn_node_unknown:
|
||
|
default:
|
||
|
text+=i18n("Unknown");
|
||
|
break;
|
||
|
}
|
||
|
text+=re;
|
||
|
if (all) {
|
||
|
text+=rb+i18n("Schedule")+cs;
|
||
|
switch ((*it).Schedule()) {
|
||
|
case svn_wc_schedule_normal:
|
||
|
text+=i18n("Normal");
|
||
|
break;
|
||
|
case svn_wc_schedule_add:
|
||
|
text+=i18n("Addition");
|
||
|
break;
|
||
|
case svn_wc_schedule_delete:
|
||
|
text+=i18n("Deletion");
|
||
|
break;
|
||
|
case svn_wc_schedule_replace:
|
||
|
text+=i18n("Replace");
|
||
|
break;
|
||
|
default:
|
||
|
text+=i18n("Unknown");
|
||
|
break;
|
||
|
}
|
||
|
text+=re;
|
||
|
text+=rb+i18n("UUID")+cs+((*it).uuid())+re;
|
||
|
}
|
||
|
text+=rb+i18n("Last author")+cs+((*it).cmtAuthor())+re;
|
||
|
if ((*it).cmtDate()>0) {
|
||
|
text+=rb+i18n("Last committed")+cs+helpers::sub2qt::DateTime2qtString((*it).cmtDate())+re;
|
||
|
}
|
||
|
text+=rb+i18n("Last revision")+cs+(*it).cmtRev().toString()+re;
|
||
|
if ((*it).textTime()>0) {
|
||
|
text+=rb+i18n("Content last changed")+cs+helpers::sub2qt::DateTime2qtString((*it).textTime())+re;
|
||
|
}
|
||
|
if (all) {
|
||
|
if ((*it).propTime()>0) {
|
||
|
text+=rb+i18n("Property last changed")+cs+helpers::sub2qt::DateTime2qtString((*it).propTime())+re;
|
||
|
}
|
||
|
if ((*it).conflictNew().length()) {
|
||
|
text+=rb+i18n("New version of conflicted file")+cs+((*it).conflictNew())+re;
|
||
|
}
|
||
|
if ((*it).conflictOld().length()) {
|
||
|
text+=rb+i18n("Old version of conflicted file")+cs+((*it).conflictOld())+re;
|
||
|
}
|
||
|
if ((*it).conflictWrk().length()) {
|
||
|
text+=rb+i18n("Working version of conflicted file")+
|
||
|
cs+((*it).conflictWrk())+re;
|
||
|
}
|
||
|
if ((*it).prejfile().length()) {
|
||
|
text+=rb+i18n("Property reject file")+
|
||
|
cs+((*it).prejfile())+re;
|
||
|
}
|
||
|
|
||
|
if ((*it).copyfromUrl().length()) {
|
||
|
text+=rb+i18n("Copy from URL")+cs+((*it).copyfromUrl())+re;
|
||
|
}
|
||
|
if ((*it).lockEntry().Locked()) {
|
||
|
text+=rb+i18n("Lock token")+cs+((*it).lockEntry().Token())+re;
|
||
|
text+=rb+i18n("Owner")+cs+((*it).lockEntry().Owner())+re;
|
||
|
text+=rb+i18n("Locked on")+cs+
|
||
|
helpers::sub2qt::DateTime2qtString((*it).lockEntry().Date())+
|
||
|
re;
|
||
|
text+=rb+i18n("Lock comment")+cs+
|
||
|
(*it).lockEntry().Comment()+re;
|
||
|
} else {
|
||
|
svn::SharedPointer<svn::Status> d;
|
||
|
if (checkReposLockCache(_what,d)&& d && d->lockEntry().Locked()) {
|
||
|
text+=rb+i18n("Lock token")+cs+(d->lockEntry().Token())+re;
|
||
|
text+=rb+i18n("Owner")+cs+(d->lockEntry().Owner())+re;
|
||
|
text+=rb+i18n("Locked on")+cs+
|
||
|
helpers::sub2qt::DateTime2qtString(d->lockEntry().Date())+
|
||
|
re;
|
||
|
text+=rb+i18n("Lock comment")+cs+
|
||
|
d->lockEntry().Comment()+re;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
text+="</table></p>\n";
|
||
|
}
|
||
|
return text;
|
||
|
}
|
||
|
|
||
|
void SvnActions::makeInfo(QPtrList<SvnItem> lst,const svn::Revision&rev,const svn::Revision&peg,bool recursive)
|
||
|
{
|
||
|
QStringList l;
|
||
|
QString res = "<html><head></head><body>";
|
||
|
SvnItem*item;
|
||
|
for (item=lst.first();item;item=lst.next()) {
|
||
|
QString text = getInfo(item->fullName(),rev,peg,recursive,true);
|
||
|
if (!text.isEmpty()) {
|
||
|
res+="<h4 align=\"center\">"+item->fullName()+"</h4>";
|
||
|
res+=text;
|
||
|
}
|
||
|
}
|
||
|
res+="</body></html>";
|
||
|
KTextBrowser*ptr;
|
||
|
KDialogBase*dlg = createDialog(&ptr,QString(i18n("Infolist")),false,"info_dialog");
|
||
|
if (dlg) {
|
||
|
ptr->setText(res);
|
||
|
dlg->exec();
|
||
|
dlg->saveDialogSize(*(Kdesvnsettings::self()->config()),"info_dialog",false);
|
||
|
delete dlg;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void SvnActions::makeInfo(const QStringList&lst,const svn::Revision&rev,const svn::Revision&peg,bool recursive)
|
||
|
{
|
||
|
QString text = "";
|
||
|
for (unsigned int i=0; i < lst.count();++i) {
|
||
|
QString res = getInfo(lst[i],rev,peg,recursive,true);
|
||
|
if (!res.isEmpty()) {
|
||
|
text+="<h4 align=\"center\">"+lst[i]+"</h4>";
|
||
|
text+=res;
|
||
|
}
|
||
|
}
|
||
|
text = "<html><head></head><body>"+text+"</body></html>";
|
||
|
KTextBrowser*ptr;
|
||
|
KDialogBase*dlg = createDialog(&ptr,QString(i18n("Infolist")),false,"info_dialog");
|
||
|
if (dlg) {
|
||
|
ptr->setText(text);
|
||
|
dlg->exec();
|
||
|
dlg->saveDialogSize(*(Kdesvnsettings::self()->config()),"info_dialog",false);
|
||
|
delete dlg;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
/*!
|
||
|
\fn SvnActions::slotProperties()
|
||
|
*/
|
||
|
void SvnActions::slotProperties()
|
||
|
{
|
||
|
/// @todo remove reference to parentlist
|
||
|
if (!m_Data->m_CurrentContext) return;
|
||
|
if (!m_Data->m_ParentList) return;
|
||
|
SvnItem*k = m_Data->m_ParentList->Selected();
|
||
|
if (!k) return;
|
||
|
PropertiesDlg dlg(k,svnclient(),
|
||
|
m_Data->m_ParentList->isWorkingCopy()?svn::Revision::WORKING:svn::Revision::HEAD);
|
||
|
connect(&dlg,SIGNAL(clientException(const QString&)),m_Data->m_ParentList->realWidget(),SLOT(slotClientException(const QString&)));
|
||
|
dlg.resize(dlg.configDialogSize(*(Kdesvnsettings::self()->config()), "properties_dlg"));
|
||
|
if (dlg.exec()!=QDialog::Accepted) {
|
||
|
return;
|
||
|
}
|
||
|
dlg.saveDialogSize(*(Kdesvnsettings::self()->config()),"properties_dlg",false);
|
||
|
QString ex;
|
||
|
svn::PropertiesMap setList;
|
||
|
QValueList<QString> delList;
|
||
|
dlg.changedItems(setList,delList);
|
||
|
changeProperties(setList,delList,k->fullName());
|
||
|
k->refreshStatus();
|
||
|
EMIT_FINISHED;
|
||
|
}
|
||
|
|
||
|
bool SvnActions::changeProperties(const svn::PropertiesMap&setList,const QValueList<QString>&delList,const QString&path)
|
||
|
{
|
||
|
try {
|
||
|
StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,"Applying properties","<center>Applying<br>hit cancel for abort</center>");
|
||
|
connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
|
||
|
unsigned int pos;
|
||
|
for (pos = 0; pos<delList.size();++pos) {
|
||
|
m_Data->m_Svnclient->propdel(delList[pos],svn::Path(path));
|
||
|
}
|
||
|
svn::PropertiesMap::ConstIterator it;
|
||
|
for (it=setList.begin(); it!=setList.end();++it) {
|
||
|
m_Data->m_Svnclient->propset(it.key(),it.data(),svn::Path(path));
|
||
|
}
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return false;
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
/*!
|
||
|
\fn SvnActions::slotCommit()
|
||
|
*/
|
||
|
void SvnActions::slotCommit()
|
||
|
{
|
||
|
if (!m_Data->m_CurrentContext||!m_Data->m_ParentList->isWorkingCopy()) {
|
||
|
return;
|
||
|
}
|
||
|
QPtrList<SvnItem> which;
|
||
|
m_Data->m_ParentList->SelectionList(&which);
|
||
|
SvnItem*cur;
|
||
|
QPtrListIterator<SvnItem> liter(which);
|
||
|
|
||
|
svn::Pathes targets;
|
||
|
if (which.count()==0) {
|
||
|
targets.push_back(svn::Path("."));
|
||
|
} else {
|
||
|
while ( (cur=liter.current())!=0) {
|
||
|
++liter;
|
||
|
targets.push_back(svn::Path(
|
||
|
m_Data->m_ParentList->relativePath(cur)
|
||
|
));
|
||
|
}
|
||
|
}
|
||
|
if (m_Data->m_ParentList->baseUri().length()>0) {
|
||
|
chdir(m_Data->m_ParentList->baseUri().local8Bit());
|
||
|
}
|
||
|
if (makeCommit(targets) && Kdesvnsettings::log_cache_on_open()) {
|
||
|
startFillCache(m_Data->m_ParentList->baseUri());
|
||
|
}
|
||
|
}
|
||
|
|
||
|
bool SvnActions::makeCommit(const svn::Targets&targets)
|
||
|
{
|
||
|
bool ok,keeplocks;
|
||
|
svn::Depth depth;
|
||
|
svn::Revision nnum;
|
||
|
svn::Targets _targets;
|
||
|
svn::Pathes _deldir;
|
||
|
bool review = Kdesvnsettings::review_commit();
|
||
|
QString msg,_p;
|
||
|
|
||
|
if (!doNetworking()) {
|
||
|
emit clientException(i18n("Not commiting because networking is disabled"));
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
stopFillCache();
|
||
|
if (!review) {
|
||
|
msg = Logmsg_impl::getLogmessage(&ok,&depth,&keeplocks,
|
||
|
m_Data->m_ParentList->realWidget(),"logmsg_impl");
|
||
|
if (!ok) {
|
||
|
return false;
|
||
|
}
|
||
|
_targets = targets;
|
||
|
} else {
|
||
|
Logmsg_impl::logActionEntries _check,_uncheck,_result;
|
||
|
svn::StatusEntries _Cache;
|
||
|
depth=svn::DepthEmpty;
|
||
|
/// @todo filter out double entries
|
||
|
for (unsigned j = 0; j < targets.size(); ++j) {
|
||
|
svn::Revision where = svn::Revision::HEAD;
|
||
|
try {
|
||
|
StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Status / List"),i18n("Creating list / check status"));
|
||
|
_Cache = m_Data->m_Svnclient->status(targets.target(j).path(),svn::DepthInfinity,false,false,false,where);
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return false;
|
||
|
}
|
||
|
for (unsigned int i = 0; i < _Cache.count();++i) {
|
||
|
_p = _Cache[i]->path();
|
||
|
if (_Cache[i]->isRealVersioned()&& (
|
||
|
_Cache[i]->textStatus()==svn_wc_status_modified||
|
||
|
_Cache[i]->textStatus()==svn_wc_status_added||
|
||
|
_Cache[i]->textStatus()==svn_wc_status_replaced||
|
||
|
_Cache[i]->textStatus()==svn_wc_status_deleted||
|
||
|
_Cache[i]->propStatus()==svn_wc_status_modified
|
||
|
) ) {
|
||
|
if (_Cache[i]->textStatus()==svn_wc_status_deleted) {
|
||
|
_check.append(Logmsg_impl::logActionEntry(_p,i18n("Delete"),Logmsg_impl::logActionEntry::DELETE));
|
||
|
} else {
|
||
|
_check.append(Logmsg_impl::logActionEntry(_p,i18n("Commit"),Logmsg_impl::logActionEntry::COMMIT));
|
||
|
}
|
||
|
} else if (_Cache[i]->textStatus()==svn_wc_status_missing) {
|
||
|
_uncheck.append(Logmsg_impl::logActionEntry(_p,i18n("Delete and Commit"),Logmsg_impl::logActionEntry::MISSING_DELETE));
|
||
|
} else if (!_Cache[i]->isVersioned()) {
|
||
|
_uncheck.append(Logmsg_impl::logActionEntry(_p,i18n("Add and Commit"),Logmsg_impl::logActionEntry::ADD_COMMIT));
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
msg = Logmsg_impl::getLogmessage(_check,_uncheck,this,_result,&ok,&keeplocks,
|
||
|
m_Data->m_ParentList->realWidget(),"logmsg_impl");
|
||
|
if (!ok||_result.count()==0) {
|
||
|
return false;
|
||
|
}
|
||
|
svn::Pathes _add,_commit,_delete;
|
||
|
for (unsigned int i=0; i < _result.count();++i) {
|
||
|
if (_result[i]._kind==Logmsg_impl::logActionEntry::DELETE) {
|
||
|
QFileInfo fi(_result[i]._name);
|
||
|
if (fi.isDir()) {
|
||
|
depth = svn::DepthInfinity;
|
||
|
}
|
||
|
}
|
||
|
_commit.append(_result[i]._name);
|
||
|
if (_result[i]._kind==Logmsg_impl::logActionEntry::ADD_COMMIT) {
|
||
|
_add.append(_result[i]._name);
|
||
|
} else if (_result[i]._kind==Logmsg_impl::logActionEntry::MISSING_DELETE) {
|
||
|
_delete.append(_result[i]._name);
|
||
|
}
|
||
|
}
|
||
|
if (_add.count()>0) {
|
||
|
if (!addItems(_add,svn::DepthEmpty)) {
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
|
if (_delete.count()>0) {
|
||
|
makeDelete(_delete);
|
||
|
}
|
||
|
_targets = svn::Targets(_commit);
|
||
|
}
|
||
|
|
||
|
try {
|
||
|
StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Commiting"),
|
||
|
i18n("Commiting - hit cancel for abort"));
|
||
|
connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
|
||
|
nnum = m_Data->m_Svnclient->commit(_targets,msg,depth,keeplocks);
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return false;
|
||
|
}
|
||
|
EMIT_REFRESH;
|
||
|
emit sendNotify(i18n("Committed revision %1.").arg(nnum.toString()));
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
/*!
|
||
|
\fn SvnActions::wroteStdin(KProcess*)
|
||
|
*/
|
||
|
void SvnActions::wroteStdin(KProcess*proc)
|
||
|
{
|
||
|
if (!proc) return;
|
||
|
kdDebug()<<"void SvnActions::wroteStdin(KProcess*proc)"<<endl;
|
||
|
proc->closeStdin();
|
||
|
}
|
||
|
|
||
|
void SvnActions::receivedStderr(KProcess*proc,char*buff,int len)
|
||
|
{
|
||
|
if (!proc || !buff || len == 0) {
|
||
|
return;
|
||
|
}
|
||
|
QString msg(QCString(buff,len));
|
||
|
emit sendNotify(msg);
|
||
|
}
|
||
|
|
||
|
void SvnActions::procClosed(KProcess*proc)
|
||
|
{
|
||
|
if (!proc) return;
|
||
|
QMap<KProcess*,QStringList>::iterator it;
|
||
|
if ( (it=m_Data->m_tempfilelist.find(proc))!=m_Data->m_tempfilelist.end()) {
|
||
|
for (QStringList::iterator it2 = (*it).begin();
|
||
|
it2 != (*it).end();++it2) {
|
||
|
::unlink((*it2).ascii());
|
||
|
}
|
||
|
m_Data->m_tempfilelist.erase(it);
|
||
|
}
|
||
|
if ( (it=m_Data->m_tempdirlist.find(proc))!=m_Data->m_tempdirlist.end()) {
|
||
|
for (QStringList::iterator it2 = (*it).begin();
|
||
|
it2 != (*it).end();++it2) {
|
||
|
KIO::NetAccess::del((*it2),0);
|
||
|
}
|
||
|
m_Data->m_tempdirlist.erase(it);
|
||
|
}
|
||
|
delete proc;
|
||
|
}
|
||
|
|
||
|
bool SvnActions::get(const QString&what,const QString& to,const svn::Revision&rev,const svn::Revision&peg,QWidget*p)
|
||
|
{
|
||
|
svn::Revision _peg = peg;
|
||
|
if (_peg == svn::Revision::UNDEFINED) {
|
||
|
_peg = rev;
|
||
|
}
|
||
|
|
||
|
try {
|
||
|
StopDlg sdlg(m_Data->m_SvnContextListener,p?p:m_Data->m_ParentList->realWidget(),0,"Downloading",
|
||
|
i18n("Download - hit cancel for abort"));
|
||
|
connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
|
||
|
m_Data->m_Svnclient->get(svn::Path(what),
|
||
|
to,rev,_peg);
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return false;
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
/*!
|
||
|
\fn SvnActions::makeDiff(const QString&,const svn::Revision&start,const svn::Revision&end)
|
||
|
*/
|
||
|
void SvnActions::makeDiff(const QString&what,const svn::Revision&start,const svn::Revision&end,const svn::Revision&_peg,bool isDir)
|
||
|
{
|
||
|
makeDiff(what,start,what,end,_peg,isDir,m_Data->m_ParentList->realWidget());
|
||
|
}
|
||
|
|
||
|
void SvnActions::makeDiff(const QString&p1,const svn::Revision&start,const QString&p2,const svn::Revision&end)
|
||
|
{
|
||
|
makeDiff(p1,start,p2,end,(QWidget*)0);
|
||
|
}
|
||
|
|
||
|
void SvnActions::makeDiff(const QString&p1,const svn::Revision&start,const QString&p2,const svn::Revision&end,QWidget*p)
|
||
|
{
|
||
|
if (!doNetworking()&&start!=svn::Revision::BASE && end!=svn::Revision::WORKING) {
|
||
|
emit sendNotify(i18n("Can not do this diff because networking is disabled."));
|
||
|
kdDebug()<<"No diff 'cause no network"<<endl;
|
||
|
return;
|
||
|
}
|
||
|
if (m_Data->isExternalDiff()) {
|
||
|
kdDebug()<<"External diff..."<<endl;
|
||
|
svn::InfoEntry info;
|
||
|
if (singleInfo(p1,start,info)) {
|
||
|
makeDiff(p1,start,p2,end,end,info.isDir(),p);
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
makeDiffinternal(p1,start,p2,end,p);
|
||
|
}
|
||
|
|
||
|
void SvnActions::makeDiffExternal(const QString&p1,const svn::Revision&start,const QString&p2,const svn::Revision&end,const svn::Revision&_peg,
|
||
|
bool isDir,QWidget*p,bool rec)
|
||
|
{
|
||
|
QString edisp = Kdesvnsettings::external_diff_display();
|
||
|
QStringList wlist = QStringList::split(" ",edisp);
|
||
|
QFileInfo f1(p1);
|
||
|
QFileInfo f2(p2);
|
||
|
KTempFile tfile(QString::null,f1.fileName()+"-"+start.toString()),tfile2(QString::null,f2.fileName()+"-"+end.toString());
|
||
|
QString s1 = f1.fileName()+"-"+start.toString();
|
||
|
QString s2 = f2.fileName()+"-"+end.toString();
|
||
|
KTempDir tdir1;
|
||
|
tdir1.setAutoDelete(true);
|
||
|
tfile.setAutoDelete(true);
|
||
|
tfile2.setAutoDelete(true);
|
||
|
QString first,second;
|
||
|
svn::Revision peg = _peg;
|
||
|
|
||
|
if (start != svn::Revision::WORKING) {
|
||
|
first = isDir?tdir1.name()+"/"+s1:tfile.name();
|
||
|
} else {
|
||
|
first = p1;
|
||
|
}
|
||
|
if (end!=svn::Revision::WORKING) {
|
||
|
second = isDir?tdir1.name()+"/"+s2:tfile2.name();
|
||
|
} else {
|
||
|
second = p2;
|
||
|
}
|
||
|
if (second == first) {
|
||
|
KMessageBox::error(m_Data->m_ParentList->realWidget(),i18n("Both entries seems to be the same, can not diff."));
|
||
|
return;
|
||
|
}
|
||
|
kdDebug()<<"Diff: "<<peg.toString()<<endl;
|
||
|
|
||
|
if (start != svn::Revision::WORKING) {
|
||
|
if (!isDir) {
|
||
|
if (!get(p1,tfile.name(),start,peg,p)) {
|
||
|
return;
|
||
|
}
|
||
|
} else {
|
||
|
if (!makeCheckout(p1,first,start,peg,
|
||
|
rec?svn::DepthInfinity:svn::DepthFiles,true,false,false,false,p)) {
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
if (end!=svn::Revision::WORKING) {
|
||
|
if (!isDir) {
|
||
|
if (!get(p2,tfile2.name(),end,peg,p)) {
|
||
|
return;
|
||
|
}
|
||
|
} else {
|
||
|
if (!makeCheckout(p2,second,end,peg,
|
||
|
rec?svn::DepthInfinity:svn::DepthFiles,true,false,false,false,p)) {
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
KProcess*proc = new KProcess();
|
||
|
for ( QStringList::Iterator it = wlist.begin();it!=wlist.end();++it) {
|
||
|
if (*it=="%1") {
|
||
|
*proc<<first;
|
||
|
} else if (*it=="%2") {
|
||
|
*proc<<second;
|
||
|
} else {
|
||
|
*proc << *it;
|
||
|
}
|
||
|
}
|
||
|
connect(proc,SIGNAL(processExited(KProcess*)),this,SLOT(procClosed(KProcess*)));
|
||
|
connect(proc,SIGNAL(receivedStderr(KProcess*,char*,int)),this,SLOT(receivedStderr(KProcess*,char*,int)));
|
||
|
connect(proc,SIGNAL(receivedStdout(KProcess*,char*,int)),this,SLOT(receivedStderr(KProcess*,char*,int)));
|
||
|
if (proc->start(m_Data->runblocked?KProcess::Block:KProcess::NotifyOnExit,KProcess::All)) {
|
||
|
if (!m_Data->runblocked) {
|
||
|
if (!isDir) {
|
||
|
tfile2.setAutoDelete(false);
|
||
|
tfile.setAutoDelete(false);
|
||
|
m_Data->m_tempfilelist[proc].append(tfile.name());
|
||
|
m_Data->m_tempfilelist[proc].append(tfile2.name());
|
||
|
} else {
|
||
|
tdir1.setAutoDelete(false);
|
||
|
m_Data->m_tempdirlist[proc].append(tdir1.name());
|
||
|
}
|
||
|
}
|
||
|
return;
|
||
|
} else {
|
||
|
emit sendNotify(i18n("Diff-process could not started, check command."));
|
||
|
}
|
||
|
delete proc;
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
void SvnActions::makeDiff(const QString&p1,const svn::Revision&start,const QString&p2,const svn::Revision&end,const svn::Revision&_peg,bool isDir,QWidget*p)
|
||
|
{
|
||
|
if (m_Data->isExternalDiff()) {
|
||
|
kdDebug()<<"External diff 2..."<<endl;
|
||
|
makeDiffExternal(p1,start,p2,end,_peg,isDir,p);
|
||
|
} else {
|
||
|
makeDiffinternal(p1,start,p2,end,p,_peg);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void SvnActions::makeDiffinternal(const QString&p1,const svn::Revision&r1,const QString&p2,const svn::Revision&r2,QWidget*p,const svn::Revision&_peg)
|
||
|
{
|
||
|
if (!m_Data->m_CurrentContext) return;
|
||
|
QByteArray ex;
|
||
|
KTempDir tdir;
|
||
|
tdir.setAutoDelete(true);
|
||
|
QString tn = QString("%1/%2").arg(tdir.name()).arg("/svndiff");
|
||
|
bool ignore_content = Kdesvnsettings::diff_ignore_content();
|
||
|
QWidget*parent = p?p:m_Data->m_ParentList->realWidget();
|
||
|
QStringList extraOptions;
|
||
|
if (Kdesvnsettings::diff_ignore_spaces())
|
||
|
{
|
||
|
extraOptions.append("-b");
|
||
|
}
|
||
|
if (Kdesvnsettings::diff_ignore_all_white_spaces())
|
||
|
{
|
||
|
extraOptions.append("-w");
|
||
|
}
|
||
|
svn::Revision peg = _peg==svn::Revision::UNDEFINED?r2:_peg;
|
||
|
|
||
|
try {
|
||
|
StopDlg sdlg(m_Data->m_SvnContextListener,parent,0,"Diffing",
|
||
|
i18n("Diffing - hit cancel for abort"));
|
||
|
connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
|
||
|
if (p1==p2 && (r1.isRemote()||r2.isRemote())) {
|
||
|
kdDebug()<<"Pegged diff"<<endl;
|
||
|
ex = m_Data->m_Svnclient->diff_peg(svn::Path(tn),
|
||
|
svn::Path(p1),svn::Path(),r1, r2,peg,
|
||
|
svn::DepthInfinity,false,false,ignore_content,extraOptions,svn::StringArray());
|
||
|
} else {
|
||
|
ex = m_Data->m_Svnclient->diff(svn::Path(tn),
|
||
|
svn::Path(p1),svn::Path(p2),svn::Path(),
|
||
|
r1, r2,
|
||
|
svn::DepthInfinity,false,false,ignore_content,extraOptions,svn::StringArray());
|
||
|
}
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return;
|
||
|
}
|
||
|
EMIT_FINISHED;
|
||
|
if (ex.isEmpty()) {
|
||
|
emit clientException(i18n("No difference to display"));
|
||
|
return;
|
||
|
}
|
||
|
dispDiff(ex);
|
||
|
}
|
||
|
|
||
|
void SvnActions::makeNorecDiff(const QString&p1,const svn::Revision&r1,const QString&p2,const svn::Revision&r2,QWidget*_p)
|
||
|
{
|
||
|
if (!m_Data->m_CurrentContext) return;
|
||
|
if (m_Data->isExternalDiff()) {
|
||
|
svn::InfoEntry info;
|
||
|
if (singleInfo(p1,r1,info)) {
|
||
|
makeDiffExternal(p1,r1,p2,r2,r2,info.isDir(),_p,false);
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
QStringList extraOptions;
|
||
|
if (Kdesvnsettings::diff_ignore_spaces())
|
||
|
{
|
||
|
extraOptions.append("-b");
|
||
|
}
|
||
|
if (Kdesvnsettings::diff_ignore_all_white_spaces())
|
||
|
{
|
||
|
extraOptions.append("-w");
|
||
|
}
|
||
|
QByteArray ex;
|
||
|
KTempDir tdir;
|
||
|
tdir.setAutoDelete(true);
|
||
|
kdDebug()<<"Non recourse diff"<<endl;
|
||
|
QString tn = QString("%1/%2").arg(tdir.name()).arg("/svndiff");
|
||
|
bool ignore_content = Kdesvnsettings::diff_ignore_content();
|
||
|
try {
|
||
|
StopDlg sdlg(m_Data->m_SvnContextListener,_p?_p:m_Data->m_ParentList->realWidget(),0,"Diffing","Diffing - hit cancel for abort");
|
||
|
connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
|
||
|
ex = m_Data->m_Svnclient->diff(svn::Path(tn),
|
||
|
svn::Path(p1),svn::Path(p2),svn::Path(),
|
||
|
r1, r2,
|
||
|
svn::DepthEmpty,false,false,ignore_content,extraOptions,svn::StringArray());
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return;
|
||
|
}
|
||
|
EMIT_FINISHED;
|
||
|
if (ex.isEmpty()) {
|
||
|
emit clientException(i18n("No difference to display"));
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
dispDiff(ex);
|
||
|
}
|
||
|
|
||
|
void SvnActions::dispDiff(const QByteArray&ex)
|
||
|
{
|
||
|
QString what = Kdesvnsettings::external_diff_display();
|
||
|
int r = KProcess::Stdin|KProcess::Stderr;
|
||
|
|
||
|
if (Kdesvnsettings::use_external_diff() && (what.find("%1")==-1 || what.find("%2")==-1)) {
|
||
|
QStringList wlist = QStringList::split(" ",what);
|
||
|
KProcess*proc = new KProcess();
|
||
|
bool fname_used = false;
|
||
|
KTempFile tfile;
|
||
|
tfile.setAutoDelete(false);
|
||
|
|
||
|
for ( QStringList::Iterator it = wlist.begin();it!=wlist.end();++it) {
|
||
|
if (*it=="%f") {
|
||
|
fname_used = true;
|
||
|
QDataStream*ds = tfile.dataStream();
|
||
|
ds->writeRawBytes(ex,ex.size());
|
||
|
tfile.close();
|
||
|
*proc<<tfile.name();
|
||
|
} else {
|
||
|
*proc << *it;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
connect(proc,SIGNAL(processExited(KProcess*)),this,SLOT(procClosed(KProcess*)));
|
||
|
connect(proc,SIGNAL(receivedStderr(KProcess*,char*,int)),this,SLOT(receivedStderr(KProcess*,char*,int)));
|
||
|
if (!fname_used) {
|
||
|
connect(proc,SIGNAL(wroteStdin(KProcess*)),this,SLOT(wroteStdin(KProcess*)));
|
||
|
}
|
||
|
if (proc->start(KProcess::NotifyOnExit,fname_used?KProcess::Stderr:(KProcess::Communication)r)) {
|
||
|
if (!fname_used) proc->writeStdin(ex,ex.size());
|
||
|
else m_Data->m_tempfilelist[proc].append(tfile.name());
|
||
|
return;
|
||
|
} else {
|
||
|
emit sendNotify(i18n("Display-process could not started, check command."));
|
||
|
}
|
||
|
delete proc;
|
||
|
}
|
||
|
bool need_modal = m_Data->runblocked||KApplication::activeModalWidget()!=0;
|
||
|
if (need_modal||!m_Data->m_DiffBrowserPtr||!m_Data->m_DiffDialog) {
|
||
|
DiffBrowser*ptr;
|
||
|
|
||
|
if (!need_modal && m_Data->m_DiffBrowserPtr) {
|
||
|
delete m_Data->m_DiffBrowserPtr;
|
||
|
}
|
||
|
KDialogBase*dlg = createDialog(&ptr,QString(i18n("Diff display")),false,
|
||
|
"diff_display",false,need_modal,
|
||
|
KStdGuiItem::saveAs());
|
||
|
if (dlg) {
|
||
|
QWidget*wd = dlg->mainWidget();
|
||
|
if (wd) {
|
||
|
EncodingSelector_impl * ls = new EncodingSelector_impl("",wd);
|
||
|
QObject::connect(ls,SIGNAL(TextCodecChanged(const QString&)),
|
||
|
ptr,SLOT(slotTextCodecChanged(const QString&)));
|
||
|
}
|
||
|
QObject::connect(dlg,SIGNAL(user1Clicked()),ptr,SLOT(saveDiff()));
|
||
|
ptr->setText(ex);
|
||
|
if (need_modal) {
|
||
|
ptr->setFocus();
|
||
|
dlg->exec();
|
||
|
dlg->saveDialogSize(*(Kdesvnsettings::self()->config()),"diff_display",false);
|
||
|
delete dlg;
|
||
|
return;
|
||
|
} else {
|
||
|
m_Data->m_DiffBrowserPtr=ptr;
|
||
|
m_Data->m_DiffDialog=dlg;
|
||
|
}
|
||
|
}
|
||
|
} else {
|
||
|
m_Data->m_DiffBrowserPtr->setText(ex);
|
||
|
m_Data->m_DiffBrowserPtr->setFocus();
|
||
|
}
|
||
|
if (m_Data->m_DiffDialog) {
|
||
|
m_Data->m_DiffDialog->show();
|
||
|
m_Data->m_DiffDialog->raise();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
/*!
|
||
|
\fn SvnActions::makeUpdate(const QString&what,const svn::Revision&rev,bool recurse)
|
||
|
*/
|
||
|
void SvnActions::makeUpdate(const QStringList&what,const svn::Revision&rev,bool recurse)
|
||
|
{
|
||
|
if (!m_Data->m_CurrentContext) return;
|
||
|
QString ex;
|
||
|
svn::Revisions ret;
|
||
|
stopCheckUpdateThread();
|
||
|
try {
|
||
|
StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,"Making update",
|
||
|
i18n("Making update - hit cancel for abort"));
|
||
|
connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
|
||
|
svn::Targets pathes(what);
|
||
|
ret = m_Data->m_Svnclient->update(pathes,rev, recurse?svn::DepthInfinity:svn::DepthFiles,false,false,true);
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return;
|
||
|
}
|
||
|
removeFromUpdateCache(what,!recurse);
|
||
|
EMIT_REFRESH;
|
||
|
EMIT_FINISHED;
|
||
|
}
|
||
|
|
||
|
/*!
|
||
|
\fn SvnActions::slotUpdateHeadRec()
|
||
|
*/
|
||
|
void SvnActions::slotUpdateHeadRec()
|
||
|
{
|
||
|
prepareUpdate(false);
|
||
|
}
|
||
|
|
||
|
|
||
|
/*!
|
||
|
\fn SvnActions::prepareUpdate(bool ask)
|
||
|
*/
|
||
|
void SvnActions::prepareUpdate(bool ask)
|
||
|
{
|
||
|
if (!m_Data->m_ParentList||!m_Data->m_ParentList->isWorkingCopy()) return;
|
||
|
SvnItemList k;
|
||
|
m_Data->m_ParentList->SelectionList(&k);
|
||
|
|
||
|
QStringList what;
|
||
|
if (k.count()==0) {
|
||
|
what.append(m_Data->m_ParentList->baseUri());
|
||
|
} else {
|
||
|
SvnItemListIterator liter(k);
|
||
|
SvnItem*cur;
|
||
|
while ((cur=liter.current())!=0){
|
||
|
++liter;
|
||
|
what.append(cur->fullName());
|
||
|
}
|
||
|
}
|
||
|
svn::Revision r(svn::Revision::HEAD);
|
||
|
if (ask) {
|
||
|
Rangeinput_impl*rdlg;
|
||
|
KDialog*dlg = createDialog(&rdlg,QString(i18n("Revisions")),true);
|
||
|
if (!dlg) {
|
||
|
return;
|
||
|
}
|
||
|
rdlg->setStartOnly(true);
|
||
|
/* just here cause layout has changed meanwhile */
|
||
|
dlg->resize( QSize(120,60).expandedTo(dlg->minimumSizeHint()) );
|
||
|
int result;
|
||
|
if ((result=dlg->exec())==QDialog::Accepted) {
|
||
|
Rangeinput_impl::revision_range range = rdlg->getRange();
|
||
|
r=range.first;
|
||
|
}
|
||
|
delete dlg;
|
||
|
if (result!=QDialog::Accepted) return;
|
||
|
}
|
||
|
makeUpdate(what,r,true);
|
||
|
}
|
||
|
|
||
|
|
||
|
/*!
|
||
|
\fn SvnActions::slotUpdateTo()
|
||
|
*/
|
||
|
void SvnActions::slotUpdateTo()
|
||
|
{
|
||
|
prepareUpdate(true);
|
||
|
}
|
||
|
|
||
|
|
||
|
/*!
|
||
|
\fn SvnActions::slotAdd()
|
||
|
*/
|
||
|
void SvnActions::slotAdd()
|
||
|
{
|
||
|
makeAdd(false);
|
||
|
}
|
||
|
|
||
|
void SvnActions::slotAddRec()
|
||
|
{
|
||
|
makeAdd(true);
|
||
|
}
|
||
|
|
||
|
void SvnActions::makeAdd(bool rec)
|
||
|
{
|
||
|
if (!m_Data->m_CurrentContext) return;
|
||
|
if (!m_Data->m_ParentList) return;
|
||
|
QPtrList<SvnItem> lst;
|
||
|
m_Data->m_ParentList->SelectionList(&lst);
|
||
|
if (lst.count()==0) {
|
||
|
KMessageBox::error(m_Data->m_ParentList->realWidget(),i18n("Which files or directories should I add?"));
|
||
|
return;
|
||
|
}
|
||
|
QValueList<svn::Path> items;
|
||
|
SvnItemListIterator liter(lst);
|
||
|
SvnItem*cur;
|
||
|
while ((cur=liter.current())!=0){
|
||
|
++liter;
|
||
|
if (cur->isVersioned()) {
|
||
|
KMessageBox::error(m_Data->m_ParentList->realWidget(),i18n("<center>The entry<br>%1<br>is versioned - break.</center>")
|
||
|
.arg(cur->fullName()));
|
||
|
return;
|
||
|
}
|
||
|
items.push_back(svn::Path(cur->fullName()));
|
||
|
}
|
||
|
addItems(items,rec?svn::DepthInfinity:svn::DepthEmpty);
|
||
|
liter.toFirst();
|
||
|
#if 0
|
||
|
while ((cur=liter.current())!=0){
|
||
|
++liter;
|
||
|
//cur->refreshStatus();
|
||
|
|
||
|
//emit sigRefreshCurrent(static_cast<FileListViewItem*>(cur->parent()));
|
||
|
}
|
||
|
#else
|
||
|
emit sigRefreshCurrent(0);
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
bool SvnActions::addItems(const QStringList&w,svn::Depth depth)
|
||
|
{
|
||
|
QValueList<svn::Path> items;
|
||
|
for (unsigned int i = 0; i<w.count();++i) {
|
||
|
items.push_back(w[i]);
|
||
|
}
|
||
|
return addItems(items,depth);
|
||
|
}
|
||
|
|
||
|
bool SvnActions::addItems(const QValueList<svn::Path> &items,svn::Depth depth)
|
||
|
{
|
||
|
QString ex;
|
||
|
try {
|
||
|
QValueList<svn::Path>::const_iterator piter;
|
||
|
for (piter=items.begin();piter!=items.end();++piter) {
|
||
|
m_Data->m_Svnclient->add((*piter),depth);
|
||
|
}
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return false;
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
bool SvnActions::makeDelete(const QStringList&w)
|
||
|
{
|
||
|
int answer = KMessageBox::questionYesNoList(0,i18n("Really delete these entries?"),w,i18n("Delete from repository"));
|
||
|
if (answer!=KMessageBox::Yes) {
|
||
|
return false;
|
||
|
}
|
||
|
svn::Pathes items;
|
||
|
for (unsigned int i = 0; i<w.count();++i) {
|
||
|
items.push_back(w[i]);
|
||
|
}
|
||
|
return makeDelete(items);
|
||
|
}
|
||
|
|
||
|
/*!
|
||
|
\fn SvnActions::makeDelete()
|
||
|
*/
|
||
|
bool SvnActions::makeDelete(const svn::Pathes&items)
|
||
|
{
|
||
|
if (!m_Data->m_CurrentContext) return false;
|
||
|
QString ex;
|
||
|
try {
|
||
|
svn::Targets target(items);
|
||
|
m_Data->m_Svnclient->remove(target,false);
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return false;
|
||
|
}
|
||
|
EMIT_FINISHED;
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
void SvnActions::slotCheckout()
|
||
|
{
|
||
|
CheckoutExport(false);
|
||
|
}
|
||
|
|
||
|
void SvnActions::slotExport()
|
||
|
{
|
||
|
CheckoutExport(true);
|
||
|
}
|
||
|
|
||
|
void SvnActions::slotCheckoutCurrent()
|
||
|
{
|
||
|
CheckoutExportCurrent(false);
|
||
|
}
|
||
|
|
||
|
void SvnActions::slotExportCurrent()
|
||
|
{
|
||
|
CheckoutExportCurrent(true);
|
||
|
}
|
||
|
|
||
|
void SvnActions::CheckoutExport(bool _exp)
|
||
|
{
|
||
|
CheckoutInfo_impl*ptr;
|
||
|
KDialogBase * dlg = createDialog(&ptr,(_exp?i18n("Export repository"):i18n("Checkout a repository")),true,"checkout_export_dialog");
|
||
|
if (dlg) {
|
||
|
if (dlg->exec()==QDialog::Accepted) {
|
||
|
svn::Revision r = ptr->toRevision();
|
||
|
bool openit = ptr->openAfterJob();
|
||
|
bool ignoreExternal=ptr->ignoreExternals();
|
||
|
makeCheckout(ptr->reposURL(),ptr->targetDir(),r,r,
|
||
|
ptr->getDepth(),
|
||
|
_exp,
|
||
|
openit,
|
||
|
ignoreExternal,
|
||
|
ptr->overwrite(),0);
|
||
|
}
|
||
|
dlg->saveDialogSize(*(Kdesvnsettings::self()->config()),"checkout_export_dialog",false);
|
||
|
delete dlg;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void SvnActions::CheckoutExport(const QString&what,bool _exp,bool urlisTarget)
|
||
|
{
|
||
|
CheckoutInfo_impl*ptr;
|
||
|
KDialog * dlg = createDialog(&ptr,_exp?i18n("Export a repository"):i18n("Checkout a repository"),true);
|
||
|
if (dlg) {
|
||
|
if (!urlisTarget) {
|
||
|
ptr->setStartUrl(what);
|
||
|
} else {
|
||
|
ptr->setTargetUrl(what);
|
||
|
}
|
||
|
if (dlg->exec()==QDialog::Accepted) {
|
||
|
svn::Revision r = ptr->toRevision();
|
||
|
bool openIt = ptr->openAfterJob();
|
||
|
bool ignoreExternal = ptr->ignoreExternals();
|
||
|
makeCheckout(ptr->reposURL(),ptr->targetDir(),r,r,ptr->getDepth(),_exp,openIt,ignoreExternal,ptr->overwrite(),0);
|
||
|
}
|
||
|
delete dlg;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void SvnActions::CheckoutExportCurrent(bool _exp)
|
||
|
{
|
||
|
if ( !m_Data->m_ParentList || (!_exp&&m_Data->m_ParentList->isWorkingCopy()) ) return;
|
||
|
SvnItem*k = m_Data->m_ParentList->Selected();
|
||
|
if (k && !k->isDir()) {
|
||
|
KMessageBox::error(m_Data->m_ParentList->realWidget(),_exp?i18n("Exporting a file?"):i18n("Checking out a file?"));
|
||
|
return;
|
||
|
}
|
||
|
QString what;
|
||
|
if (!k) {
|
||
|
what = m_Data->m_ParentList->baseUri();
|
||
|
} else {
|
||
|
what = k->fullName();
|
||
|
}
|
||
|
CheckoutExport(what,_exp);
|
||
|
}
|
||
|
|
||
|
bool SvnActions::makeCheckout(const QString&rUrl,const QString&tPath,const svn::Revision&r,const svn::Revision&_peg,
|
||
|
svn::Depth depth,
|
||
|
// kind of operation
|
||
|
bool _exp,
|
||
|
// open after job
|
||
|
bool openIt,
|
||
|
// ignore externals
|
||
|
bool ignoreExternal,
|
||
|
// overwrite/force not versioned items
|
||
|
bool overwrite,
|
||
|
QWidget*_p
|
||
|
)
|
||
|
{
|
||
|
QString fUrl = rUrl;
|
||
|
QString ex;
|
||
|
while (fUrl.endsWith("/")) {
|
||
|
fUrl.truncate(fUrl.length()-1);
|
||
|
}
|
||
|
svn::Path p(tPath);
|
||
|
svn::Revision peg = _peg;
|
||
|
if (r!=svn::Revision::BASE && r!=svn::Revision::WORKING && _peg==svn::Revision::UNDEFINED) {
|
||
|
peg = r;
|
||
|
}
|
||
|
if (!_exp||!m_Data->m_CurrentContext) reInitClient();
|
||
|
try {
|
||
|
StopDlg sdlg(m_Data->m_SvnContextListener,_p?_p:m_Data->m_ParentList->realWidget(),0,_exp?i18n("Export"):i18n("Checkout"),_exp?i18n("Exporting"):i18n("Checking out"));
|
||
|
connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
|
||
|
if (_exp) {
|
||
|
/// @todo setup parameter for export operation
|
||
|
m_Data->m_Svnclient->doExport(svn::Path(fUrl),p,r,peg,overwrite,QString::null,ignoreExternal,depth);
|
||
|
} else {
|
||
|
m_Data->m_Svnclient->checkout(fUrl,p,r,peg,depth,ignoreExternal,overwrite);
|
||
|
}
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return false;
|
||
|
}
|
||
|
if (openIt) {
|
||
|
if (!_exp) emit sigGotourl(tPath);
|
||
|
else kapp->invokeBrowser(tPath);
|
||
|
}
|
||
|
EMIT_FINISHED;
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
void SvnActions::slotRevert()
|
||
|
{
|
||
|
if (!m_Data->m_ParentList||!m_Data->m_ParentList->isWorkingCopy()) return;
|
||
|
QPtrList<SvnItem> lst;
|
||
|
m_Data->m_ParentList->SelectionList(&lst);
|
||
|
QStringList displist;
|
||
|
SvnItemListIterator liter(lst);
|
||
|
SvnItem*cur;
|
||
|
if (lst.count()>0) {
|
||
|
while ((cur=liter.current())!=0){
|
||
|
if (!cur->isVersioned()) {
|
||
|
KMessageBox::error(m_Data->m_ParentList->realWidget(),i18n("<center>The entry<br>%1<br>is not versioned - break.</center>")
|
||
|
.arg(cur->fullName()));
|
||
|
return;
|
||
|
}
|
||
|
displist.append(cur->fullName());
|
||
|
++liter;
|
||
|
}
|
||
|
} else {
|
||
|
displist.push_back(m_Data->m_ParentList->baseUri());
|
||
|
}
|
||
|
slotRevertItems(displist);
|
||
|
EMIT_REFRESH;
|
||
|
}
|
||
|
|
||
|
void SvnActions::slotRevertItems(const QStringList&displist)
|
||
|
{
|
||
|
if (!m_Data->m_CurrentContext) return;
|
||
|
if (displist.count()==0) {
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
svn::Depth depth;
|
||
|
RevertFormImpl*ptr;
|
||
|
KDialog * dlg = createDialog(&ptr,i18n("Revert entries"),true);
|
||
|
if (!dlg) {
|
||
|
return;
|
||
|
}
|
||
|
ptr->setDispList(displist);
|
||
|
if (dlg->exec()!=QDialog::Accepted) {
|
||
|
delete dlg;
|
||
|
return;
|
||
|
}
|
||
|
depth = ptr->getDepth();
|
||
|
|
||
|
QValueList<svn::Path> items;
|
||
|
for (unsigned j = 0; j<displist.count();++j) {
|
||
|
items.push_back(svn::Path((*(displist.at(j)))));
|
||
|
}
|
||
|
QString ex;
|
||
|
|
||
|
try {
|
||
|
StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Revert"),i18n("Reverting items"));
|
||
|
connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
|
||
|
svn::Targets target(items);
|
||
|
m_Data->m_Svnclient->revert(target,depth);
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return;
|
||
|
}
|
||
|
// remove them from cache
|
||
|
for (unsigned int j = 0; j<items.count();++j) {
|
||
|
m_Data->m_Cache.deleteKey(items[j].path(),depth!=svn::DepthInfinity);
|
||
|
// m_Data->m_Cache.dump_tree();
|
||
|
}
|
||
|
EMIT_FINISHED;
|
||
|
}
|
||
|
|
||
|
bool SvnActions::makeSwitch(const QString&rUrl,const QString&tPath,const svn::Revision&r,svn::Depth depth,const svn::Revision&peg,bool stickydepth,bool ignore_externals,bool allow_unversioned)
|
||
|
{
|
||
|
if (!m_Data->m_CurrentContext) return false;
|
||
|
QString fUrl = rUrl;
|
||
|
QString ex;
|
||
|
while (fUrl.endsWith("/")) {
|
||
|
fUrl.truncate(fUrl.length()-1);
|
||
|
}
|
||
|
svn::Path p(tPath);
|
||
|
try {
|
||
|
StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Switch url"),i18n("Switching url"));
|
||
|
connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
|
||
|
m_Data->m_Svnclient->doSwitch(p,fUrl,r,depth,peg,stickydepth,ignore_externals,allow_unversioned);
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return false;
|
||
|
}
|
||
|
EMIT_FINISHED;
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
bool SvnActions::makeRelocate(const QString&fUrl,const QString&tUrl,const QString&path,bool rec)
|
||
|
{
|
||
|
if (!m_Data->m_CurrentContext) return false;
|
||
|
QString _f = fUrl;
|
||
|
QString _t = tUrl;
|
||
|
QString ex;
|
||
|
while (_f.endsWith("/")) {
|
||
|
_f.truncate(_f.length()-1);
|
||
|
}
|
||
|
while (_t.endsWith("/")) {
|
||
|
_t.truncate(_t.length()-1);
|
||
|
}
|
||
|
svn::Path p(path);
|
||
|
try {
|
||
|
StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Relocate url"),i18n("Relocate repository to new URL"));
|
||
|
connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
|
||
|
m_Data->m_Svnclient->relocate(p,_f,_t,rec);
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return false;
|
||
|
}
|
||
|
EMIT_FINISHED;
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
void SvnActions::slotSwitch()
|
||
|
{
|
||
|
if (!m_Data->m_CurrentContext) return;
|
||
|
if (!m_Data->m_ParentList||!m_Data->m_ParentList->isWorkingCopy()) return;
|
||
|
|
||
|
QPtrList<SvnItem> lst;
|
||
|
m_Data->m_ParentList->SelectionList(&lst);
|
||
|
|
||
|
if (lst.count()>1) {
|
||
|
KMessageBox::error(0,i18n("Can only switch one item at time"));
|
||
|
return;
|
||
|
}
|
||
|
SvnItem*k;
|
||
|
|
||
|
k = m_Data->m_ParentList->SelectedOrMain();
|
||
|
if (!k) {
|
||
|
KMessageBox::error(0,i18n("Error getting entry to switch"));
|
||
|
return;
|
||
|
}
|
||
|
QString path,what;
|
||
|
path = k->fullName();
|
||
|
what = k->Url();
|
||
|
if (makeSwitch(path,what)) {
|
||
|
emit reinitItem(k);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
bool SvnActions::makeSwitch(const QString&path,const QString&what)
|
||
|
{
|
||
|
CheckoutInfo_impl*ptr;
|
||
|
KDialogBase * dlg = createDialog(&ptr,i18n("Switch url"),true,"switch_url_dlg");
|
||
|
bool done = false;
|
||
|
if (dlg) {
|
||
|
ptr->setStartUrl(what);
|
||
|
ptr->disableAppend(true);
|
||
|
ptr->disableTargetDir(true);
|
||
|
ptr->disableOpen(true);
|
||
|
if (dlg->exec()==QDialog::Accepted) {
|
||
|
svn::Revision r = ptr->toRevision();
|
||
|
done = makeSwitch(ptr->reposURL(),path,r,ptr->getDepth(),r,true,ptr->ignoreExternals(),ptr->overwrite());
|
||
|
}
|
||
|
dlg->saveDialogSize(*(Kdesvnsettings::self()->config()),"switch_url_dlg",false);
|
||
|
delete dlg;
|
||
|
}
|
||
|
return done;
|
||
|
}
|
||
|
|
||
|
bool SvnActions::makeCleanup(const QString&path)
|
||
|
{
|
||
|
if (!m_Data->m_CurrentContext) return false;
|
||
|
try {
|
||
|
StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Cleanup"),i18n("Cleaning up folder"));
|
||
|
connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
|
||
|
m_Data->m_Svnclient->cleanup(svn::Path(path));
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return false;
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
void SvnActions::slotResolved(const QString&path)
|
||
|
{
|
||
|
if (!m_Data->m_CurrentContext) return;
|
||
|
try {
|
||
|
StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Resolve"),i18n("Marking resolved"));
|
||
|
connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
|
||
|
m_Data->m_Svnclient->resolve(svn::Path(path),svn::DepthEmpty);
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return;
|
||
|
}
|
||
|
m_Data->m_conflictCache.deleteKey(path,false);
|
||
|
}
|
||
|
|
||
|
void SvnActions::slotResolve(const QString&p)
|
||
|
{
|
||
|
if (!m_Data->m_CurrentContext) return;
|
||
|
QString eresolv = Kdesvnsettings::conflict_resolver();
|
||
|
QStringList wlist = QStringList::split(" ",eresolv);
|
||
|
if (wlist.size()==0) {
|
||
|
return;
|
||
|
}
|
||
|
kdDebug()<<"Resolve: "<<p<<endl;
|
||
|
svn::InfoEntry i1;
|
||
|
if (!singleInfo(p,svn::Revision::UNDEFINED,i1)) {
|
||
|
return;
|
||
|
}
|
||
|
QFileInfo fi(p);
|
||
|
QString base = fi.dirPath(true);
|
||
|
kdDebug()<<i1.conflictNew()<<" "
|
||
|
<<i1.conflictOld()<<" "
|
||
|
<<i1.conflictWrk()<<" "
|
||
|
<<endl;
|
||
|
if (!i1.conflictNew().length()||
|
||
|
!i1.conflictOld().length()||
|
||
|
!i1.conflictWrk().length() ) {
|
||
|
emit sendNotify(i18n("Could not retrieve conflict information - giving up."));
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
KProcess*proc = new KProcess();
|
||
|
for ( QStringList::Iterator it = wlist.begin();it!=wlist.end();++it) {
|
||
|
if (*it=="%o"||*it=="%l") {
|
||
|
*proc<<(base+"/"+i1.conflictOld());
|
||
|
} else if (*it=="%m" || *it=="%w") {
|
||
|
*proc<<(base+"/"+i1.conflictWrk());
|
||
|
} else if (*it=="%n"||*it=="%r") {
|
||
|
*proc<<(base+"/"+i1.conflictNew());
|
||
|
} else if (*it=="%t") {
|
||
|
*proc<<p;
|
||
|
} else {
|
||
|
*proc << *it;
|
||
|
}
|
||
|
}
|
||
|
connect(proc,SIGNAL(processExited(KProcess*)),this,SLOT(procClosed(KProcess*)));
|
||
|
connect(proc,SIGNAL(receivedStderr(KProcess*,char*,int)),this,SLOT(receivedStderr(KProcess*,char*,int)));
|
||
|
connect(proc,SIGNAL(receivedStdout(KProcess*,char*,int)),this,SLOT(receivedStderr(KProcess*,char*,int)));
|
||
|
if (proc->start(m_Data->runblocked?KProcess::Block:KProcess::NotifyOnExit,KProcess::All)) {
|
||
|
return;
|
||
|
} else {
|
||
|
emit sendNotify(i18n("Resolve-process could not started, check command."));
|
||
|
}
|
||
|
delete proc;
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
void SvnActions::slotImport(const QString&path,const QString&target,const QString&message,svn::Depth depth,
|
||
|
bool noIgnore,bool noUnknown)
|
||
|
{
|
||
|
if (!m_Data->m_CurrentContext) return;
|
||
|
try {
|
||
|
StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Import"),i18n("Importing items"));
|
||
|
connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
|
||
|
m_Data->m_Svnclient->import(svn::Path(path),target,message,depth,noIgnore,noUnknown);
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void SvnActions::slotMergeExternal(const QString&_src1,const QString&_src2, const QString&_target,
|
||
|
const svn::Revision&rev1,const svn::Revision&rev2,const svn::Revision&_peg,bool rec)
|
||
|
{
|
||
|
KTempDir tdir1;
|
||
|
tdir1.setAutoDelete(true);
|
||
|
QString src1 = _src1;
|
||
|
QString src2 = _src2;
|
||
|
QString target = _target;
|
||
|
bool singleMerge = false;
|
||
|
|
||
|
if (rev1 == rev2 && (src2.isEmpty() || src1==src2) ) {
|
||
|
singleMerge = true;
|
||
|
}
|
||
|
if (src1.isEmpty()) {
|
||
|
emit clientException(i18n("Nothing to merge."));
|
||
|
return;
|
||
|
}
|
||
|
if (target.isEmpty()) {
|
||
|
emit clientException(i18n("No destination to merge."));
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
KURL url(target);
|
||
|
if (!url.isLocalFile()) {
|
||
|
emit clientException(i18n("Target for merge must be local!"));
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
QFileInfo f1(src1);
|
||
|
QFileInfo f2(src2);
|
||
|
bool isDir = true;
|
||
|
|
||
|
svn::InfoEntry i1,i2;
|
||
|
|
||
|
if (!singleInfo(src1,rev1,i1)) {
|
||
|
return;
|
||
|
}
|
||
|
isDir = i1.isDir();
|
||
|
if (!singleMerge && src1 != src2) {
|
||
|
if (!singleInfo(src2,rev2,i2)) {
|
||
|
return;
|
||
|
}
|
||
|
if (i2.isDir()!=isDir) {
|
||
|
emit clientException(i18n("Both sources must be same type!"));
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
QFileInfo ti(target);
|
||
|
|
||
|
if (ti.isDir()!=isDir) {
|
||
|
emit clientException(i18n("Target for merge must same type like sources!"));
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
QString s1 = f1.fileName()+"-"+rev1.toString();
|
||
|
QString s2 = f2.fileName()+"-"+rev2.toString();
|
||
|
QString first,second,out;
|
||
|
if (rev1 != svn::Revision::WORKING) {
|
||
|
first = tdir1.name()+"/"+s1;
|
||
|
} else {
|
||
|
first = src1;
|
||
|
}
|
||
|
if (!singleMerge) {
|
||
|
if (rev2!=svn::Revision::WORKING) {
|
||
|
second = tdir1.name()+"/"+s2;
|
||
|
} else {
|
||
|
second = src2;
|
||
|
}
|
||
|
} else {
|
||
|
// only two-way merge
|
||
|
second = QString::null;
|
||
|
}
|
||
|
if (second == first) {
|
||
|
KMessageBox::error(m_Data->m_ParentList->realWidget(),i18n("Both entries seems to be the same, won't do a merge."));
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
if (rev1 != svn::Revision::WORKING) {
|
||
|
if (isDir) {
|
||
|
if (!makeCheckout(src1,first,rev1,svn::Revision::UNDEFINED,
|
||
|
rec?svn::DepthInfinity:svn::DepthFiles,
|
||
|
true,
|
||
|
false,
|
||
|
false,
|
||
|
false,0)) {
|
||
|
return;
|
||
|
}
|
||
|
} else {
|
||
|
if (!get(src1,first,rev1,svn::Revision::UNDEFINED,m_Data->m_ParentList->realWidget())) {
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (!singleMerge) {
|
||
|
if (rev2!=svn::Revision::WORKING) {
|
||
|
if (isDir) {
|
||
|
if (!makeCheckout(src2,second,rev2,svn::Revision::UNDEFINED,
|
||
|
rec?svn::DepthInfinity:svn::DepthFiles,
|
||
|
true,false,false,false,0)) {
|
||
|
return;
|
||
|
}
|
||
|
} else {
|
||
|
if (!get(src2,second,rev2,svn::Revision::UNDEFINED,m_Data->m_ParentList->realWidget())) {
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
QString edisp = Kdesvnsettings::external_merge_program();
|
||
|
QStringList wlist = QStringList::split(" ",edisp);
|
||
|
KProcess*proc = new KProcess();
|
||
|
for ( QStringList::Iterator it = wlist.begin();it!=wlist.end();++it) {
|
||
|
if (*it=="%s1") {
|
||
|
*proc<<first;
|
||
|
} else if (*it=="%s2") {
|
||
|
if (!second.isEmpty()) *proc<<second;
|
||
|
} else if (*it=="%t") {
|
||
|
*proc<<target;
|
||
|
} else {
|
||
|
*proc << *it;
|
||
|
}
|
||
|
}
|
||
|
connect(proc,SIGNAL(processExited(KProcess*)),this,SLOT(procClosed(KProcess*)));
|
||
|
connect(proc,SIGNAL(receivedStderr(KProcess*,char*,int)),this,SLOT(receivedStderr(KProcess*,char*,int)));
|
||
|
if (proc->start(m_Data->runblocked?KProcess::Block:KProcess::NotifyOnExit,KProcess::Stderr)) {
|
||
|
if (!m_Data->runblocked) {
|
||
|
tdir1.setAutoDelete(false);
|
||
|
m_Data->m_tempdirlist[proc].append(tdir1.name());
|
||
|
}
|
||
|
return;
|
||
|
} else {
|
||
|
emit sendNotify(i18n("Merge-process could not started, check command."));
|
||
|
}
|
||
|
delete proc;
|
||
|
}
|
||
|
|
||
|
void SvnActions::slotMergeWcRevisions(const QString&_entry,const svn::Revision&rev1,
|
||
|
const svn::Revision&rev2,
|
||
|
bool rec,bool ancestry,bool forceIt,bool dry)
|
||
|
{
|
||
|
slotMerge(_entry,_entry,_entry,rev1,rev2,svn::Revision::UNDEFINED,rec,ancestry,forceIt,dry);
|
||
|
}
|
||
|
|
||
|
void SvnActions::slotMerge(const QString&src1,const QString&src2, const QString&target,
|
||
|
const svn::Revision&rev1,const svn::Revision&rev2,const svn::Revision&_peg,
|
||
|
bool rec,bool ancestry,bool forceIt,bool dry)
|
||
|
{
|
||
|
if (!m_Data->m_CurrentContext) return;
|
||
|
QString s2;
|
||
|
|
||
|
svn::Revision peg = svn::Revision::HEAD;
|
||
|
svn::Revision tpeg;
|
||
|
svn::RevisionRanges ranges;
|
||
|
svn::Path p1;
|
||
|
try {
|
||
|
svn::Path::parsePeg(src1,p1,tpeg);
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return;
|
||
|
}
|
||
|
if (tpeg!=svn::Revision::UNDEFINED) {
|
||
|
peg=tpeg;
|
||
|
}
|
||
|
svn::Path p2(src2);
|
||
|
|
||
|
bool pegged_merge=false;
|
||
|
|
||
|
if(!p2.isset() || src1==src2) {
|
||
|
// pegged merge
|
||
|
pegged_merge=true;
|
||
|
ranges.append(svn::RevisionRange(rev1,rev2));
|
||
|
if (peg==svn::Revision::UNDEFINED) {
|
||
|
if (p1.isUrl()) {
|
||
|
peg = rev2;
|
||
|
} else {
|
||
|
peg=svn::Revision::WORKING;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
try {
|
||
|
StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Merge"),i18n("Merging items"));
|
||
|
connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
|
||
|
if (pegged_merge) {
|
||
|
m_Data->m_Svnclient->merge_peg(p1,ranges,svn::Revision::HEAD,svn::Path(target),rec?svn::DepthUnknown:svn::DepthFiles,
|
||
|
ancestry,dry,forceIt,false);
|
||
|
} else {
|
||
|
m_Data->m_Svnclient->merge(p1,rev1,p2,rev2,
|
||
|
svn::Path(target),
|
||
|
forceIt,rec?svn::DepthUnknown:svn::DepthFiles,ancestry,dry);
|
||
|
}
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/*!
|
||
|
\fn SvnActions::slotCopyMove(bool,const QString&,const QString&)
|
||
|
*/
|
||
|
bool SvnActions::makeMove(const QString&Old,const QString&New,bool force)
|
||
|
{
|
||
|
if (!m_Data->m_CurrentContext) return false;
|
||
|
svn::Revision nnum;
|
||
|
try {
|
||
|
StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Move"),i18n("Moving/Rename item "));
|
||
|
connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
|
||
|
nnum = m_Data->m_Svnclient->move(svn::Path(Old),svn::Path(New),force);
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return false;
|
||
|
}
|
||
|
if (nnum != svn::Revision::UNDEFINED) {
|
||
|
emit sendNotify(i18n("Committed revision %1.").arg(nnum.toString()));
|
||
|
}
|
||
|
EMIT_REFRESH;
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
bool SvnActions::makeMove(const KURL::List&Old,const QString&New,bool force)
|
||
|
{
|
||
|
svn::Revision nnum;
|
||
|
try {
|
||
|
StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Move"),i18n("Moving entries"));
|
||
|
connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
|
||
|
KURL::List::ConstIterator it = Old.begin();
|
||
|
bool local = false;
|
||
|
|
||
|
if ((*it).protocol().isEmpty()) {
|
||
|
local = true;
|
||
|
}
|
||
|
it = Old.begin();
|
||
|
svn::Pathes p;
|
||
|
for (;it!=Old.end();++it) {
|
||
|
p.append((local?(*it).path():(*it).url()));
|
||
|
}
|
||
|
svn::Targets t(p);
|
||
|
svn::Path NPath(New);
|
||
|
m_Data->m_Svnclient->move(t,NPath,force,true,false);
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return false;
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
bool SvnActions::makeCopy(const QString&Old,const QString&New,const svn::Revision&rev)
|
||
|
{
|
||
|
if (!m_Data->m_CurrentContext) return false;
|
||
|
try {
|
||
|
StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Copy / Move"),i18n("Copy or Moving entries"));
|
||
|
connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
|
||
|
m_Data->m_Svnclient->copy(svn::Path(Old),rev,svn::Path(New));
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return false;
|
||
|
}
|
||
|
EMIT_REFRESH;
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
bool SvnActions::makeCopy(const KURL::List&Old,const QString&New,const svn::Revision&rev)
|
||
|
{
|
||
|
KURL::List::ConstIterator it = Old.begin();
|
||
|
svn::Pathes p;
|
||
|
bool local = false;
|
||
|
if ((*it).protocol().isEmpty()) {
|
||
|
local = true;
|
||
|
}
|
||
|
for (;it!=Old.end();++it) {
|
||
|
p.append((local?(*it).path():(*it).url()));
|
||
|
}
|
||
|
svn::Targets t(p);
|
||
|
|
||
|
try {
|
||
|
StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Copy / Move"),i18n("Copy or Moving entries"));
|
||
|
connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
|
||
|
KURL::List::ConstIterator it = Old.begin();
|
||
|
m_Data->m_Svnclient->copy(t,rev,rev,svn::Path(New),true);
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return false;
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
/*!
|
||
|
\fn SvnActions::makeLock(const QStringList&)
|
||
|
*/
|
||
|
void SvnActions::makeLock(const QStringList&what,const QString&_msg,bool breakit)
|
||
|
{
|
||
|
QValueList<svn::Path> targets;
|
||
|
for (unsigned int i = 0; i<what.count();++i) {
|
||
|
targets.push_back(svn::Path((*(what.at(i)))));
|
||
|
}
|
||
|
if (!m_Data->m_CurrentContext) return;
|
||
|
try {
|
||
|
m_Data->m_Svnclient->lock(svn::Targets(targets),_msg,breakit);
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
/*!
|
||
|
\fn SvnActions::makeUnlock(const QStringList&)
|
||
|
*/
|
||
|
void SvnActions::makeUnlock(const QStringList&what,bool breakit)
|
||
|
{
|
||
|
QValueList<svn::Path> targets;
|
||
|
if (!m_Data->m_CurrentContext) return;
|
||
|
for (unsigned int i = 0; i<what.count();++i) {
|
||
|
targets.push_back(svn::Path((*(what.at(i)))));
|
||
|
}
|
||
|
|
||
|
try {
|
||
|
m_Data->m_Svnclient->unlock(svn::Targets(targets),breakit);
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return;
|
||
|
}
|
||
|
for (unsigned int i = 0; i<what.count();++i) {
|
||
|
m_Data->m_repoLockCache.deleteKey(*(what.at(i)),true);
|
||
|
}
|
||
|
// m_Data->m_repoLockCache.dump_tree();
|
||
|
}
|
||
|
|
||
|
|
||
|
/*!
|
||
|
\fn SvnActions::makeStatus(const QString&what, svn::StatusEntries&dlist)
|
||
|
*/
|
||
|
bool SvnActions::makeStatus(const QString&what, svn::StatusEntries&dlist, svn::Revision&where,bool rec,bool all)
|
||
|
{
|
||
|
bool display_ignores = Kdesvnsettings::display_ignored_files();
|
||
|
return makeStatus(what,dlist,where,rec,all,display_ignores);
|
||
|
}
|
||
|
|
||
|
bool SvnActions::makeStatus(const QString&what, svn::StatusEntries&dlist, svn::Revision&where,bool rec,bool all,bool display_ignores,bool updates)
|
||
|
{
|
||
|
bool disp_remote_details = Kdesvnsettings::details_on_remote_listing();
|
||
|
QString ex;
|
||
|
svn::Depth _d=rec?svn::DepthInfinity:svn::DepthImmediates;
|
||
|
try {
|
||
|
StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Status / List"),i18n("Creating list / check status"));
|
||
|
connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
|
||
|
// rec all up noign
|
||
|
dlist = m_Data->m_Svnclient->status(what,_d,all,updates,display_ignores,where,disp_remote_details,false);
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return false;
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
void SvnActions::checkAddItems(const QString&path,bool print_error_box)
|
||
|
{
|
||
|
svn::StatusEntries dlist;
|
||
|
svn::StatusEntries rlist;
|
||
|
QStringList displist;
|
||
|
svn::Revision where = svn::Revision::HEAD;
|
||
|
if (!makeStatus(path,dlist,where,true,true,false,false)) {
|
||
|
return;
|
||
|
}
|
||
|
for (unsigned int i = 0; i<dlist.size();++i) {
|
||
|
if (!dlist[i]->isVersioned()) {
|
||
|
rlist.append(dlist[i]);
|
||
|
displist.append(dlist[i]->path());
|
||
|
}
|
||
|
}
|
||
|
if (rlist.size()==0) {
|
||
|
if (print_error_box) KMessageBox::error(m_Data->m_ParentList->realWidget(),i18n("No unversioned items found."));
|
||
|
} else {
|
||
|
KListView*ptr;
|
||
|
KDialogBase * dlg = createDialog(&ptr,i18n("Add unversioned items"),true,"add_items_dlg");
|
||
|
ptr->addColumn("Item");
|
||
|
for (unsigned j = 0; j<displist.size();++j) {
|
||
|
QCheckListItem * n = new QCheckListItem(ptr,displist[j],QCheckListItem::CheckBox);
|
||
|
n->setOn(true);
|
||
|
}
|
||
|
if (dlg->exec()==QDialog::Accepted) {
|
||
|
QListViewItemIterator it(ptr);
|
||
|
displist.clear();
|
||
|
while(it.current()) {
|
||
|
QCheckListItem*t = (QCheckListItem*)it.current();
|
||
|
if (t->isOn()) {
|
||
|
displist.append(t->text());
|
||
|
}
|
||
|
++it;
|
||
|
}
|
||
|
if (displist.count()>0) {
|
||
|
addItems(displist,svn::DepthEmpty);
|
||
|
}
|
||
|
}
|
||
|
dlg->saveDialogSize(*(Kdesvnsettings::self()->config()),"add_items_dlg",false);
|
||
|
delete dlg;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void SvnActions::stopCheckModThread()
|
||
|
{
|
||
|
m_Data->m_ThreadCheckTimer.stop();
|
||
|
if (m_CThread) {
|
||
|
m_CThread->cancelMe();
|
||
|
if (!m_CThread->wait(MAX_THREAD_WAITTIME)) {
|
||
|
m_CThread->terminate();
|
||
|
m_CThread->wait(MAX_THREAD_WAITTIME);
|
||
|
}
|
||
|
delete m_CThread;
|
||
|
m_CThread=0;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void SvnActions::stopCheckUpdateThread()
|
||
|
{
|
||
|
m_Data->m_UpdateCheckTimer.stop();
|
||
|
if (m_UThread) {
|
||
|
m_UThread->cancelMe();
|
||
|
if (!m_UThread->wait(MAX_THREAD_WAITTIME)) {
|
||
|
m_UThread->terminate();
|
||
|
m_UThread->wait(MAX_THREAD_WAITTIME);
|
||
|
}
|
||
|
delete m_UThread;
|
||
|
m_UThread=0;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void SvnActions::stopFillCache()
|
||
|
{
|
||
|
if (m_FCThread) {
|
||
|
m_FCThread->cancelMe();
|
||
|
if (!m_FCThread->wait(MAX_THREAD_WAITTIME)) {
|
||
|
m_FCThread->terminate();
|
||
|
m_FCThread->wait(MAX_THREAD_WAITTIME);
|
||
|
}
|
||
|
delete m_FCThread;
|
||
|
m_FCThread = 0;
|
||
|
emit sigCacheStatus(-1,-1);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void SvnActions::stopMain()
|
||
|
{
|
||
|
if (m_Data->m_CurrentContext) {
|
||
|
m_Data->m_SvnContextListener->setCanceled(true);
|
||
|
sleep(1);
|
||
|
m_Data->m_SvnContextListener->contextCancel();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void SvnActions::killallThreads()
|
||
|
{
|
||
|
stopMain();
|
||
|
stopCheckModThread();
|
||
|
stopCheckUpdateThread();
|
||
|
stopFillCache();
|
||
|
}
|
||
|
|
||
|
bool SvnActions::createModifiedCache(const QString&what)
|
||
|
{
|
||
|
stopCheckModThread();
|
||
|
m_Data->m_Cache.clear();
|
||
|
m_Data->m_conflictCache.clear();
|
||
|
kdDebug()<<"Create cache for " << what << endl;
|
||
|
m_CThread = new CheckModifiedThread(this,what);
|
||
|
m_CThread->start();
|
||
|
m_Data->m_ThreadCheckTimer.start(100,true);
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
void SvnActions::checkModthread()
|
||
|
{
|
||
|
if (!m_CThread)return;
|
||
|
if (m_CThread->running()) {
|
||
|
m_Data->m_ThreadCheckTimer.start(100,true);
|
||
|
return;
|
||
|
}
|
||
|
kdDebug()<<"ModifiedThread seems stopped"<<endl;
|
||
|
for (unsigned int i = 0; i < m_CThread->getList().count();++i) {
|
||
|
svn::StatusPtr ptr = m_CThread->getList()[i];
|
||
|
if (m_CThread->getList()[i]->isRealVersioned()&& (
|
||
|
m_CThread->getList()[i]->textStatus()==svn_wc_status_modified||
|
||
|
m_CThread->getList()[i]->textStatus()==svn_wc_status_added||
|
||
|
m_CThread->getList()[i]->textStatus()==svn_wc_status_deleted||
|
||
|
m_CThread->getList()[i]->textStatus()==svn_wc_status_replaced||
|
||
|
m_CThread->getList()[i]->propStatus()==svn_wc_status_modified
|
||
|
) ) {
|
||
|
m_Data->m_Cache.insertKey(ptr,ptr->path());
|
||
|
} else if (m_CThread->getList()[i]->textStatus()==svn_wc_status_conflicted) {
|
||
|
m_Data->m_conflictCache.insertKey(ptr,ptr->path());
|
||
|
}
|
||
|
}
|
||
|
delete m_CThread;
|
||
|
m_CThread = 0;
|
||
|
emit sigRefreshIcons(false);
|
||
|
}
|
||
|
|
||
|
void SvnActions::checkUpdateThread()
|
||
|
{
|
||
|
if (!m_UThread)return;
|
||
|
if (m_UThread->running()) {
|
||
|
if (m_Data->m_UpdateCheckTick.elapsed()>2500) {
|
||
|
m_Data->m_UpdateCheckTick.restart();
|
||
|
emit sendNotify(i18n("Still checking for updates"));
|
||
|
}
|
||
|
m_Data->m_UpdateCheckTimer.start(100,true);
|
||
|
return;
|
||
|
}
|
||
|
kdDebug()<<"Updates Thread seems stopped"<<endl;
|
||
|
|
||
|
bool newer=false;
|
||
|
for (unsigned int i = 0; i < m_UThread->getList().count();++i) {
|
||
|
svn::StatusPtr ptr = m_UThread->getList()[i];
|
||
|
if (ptr->validReposStatus()) {
|
||
|
m_Data->m_UpdateCache.insertKey(ptr,ptr->path());
|
||
|
ptr->textStatus();
|
||
|
ptr->propStatus();
|
||
|
if (!(ptr->validLocalStatus())) {
|
||
|
newer = true;
|
||
|
}
|
||
|
}
|
||
|
if (ptr->isLocked() &&
|
||
|
!(ptr->entry().lockEntry().Locked())) {
|
||
|
m_Data->m_repoLockCache.insertKey(ptr,ptr->path());
|
||
|
}
|
||
|
}
|
||
|
emit sigRefreshIcons(newer);
|
||
|
emit sendNotify(i18n("Checking for updates finished"));
|
||
|
if (newer) {
|
||
|
emit sendNotify(i18n("There are new items in repository"));
|
||
|
}
|
||
|
delete m_UThread;
|
||
|
m_UThread = 0;
|
||
|
}
|
||
|
|
||
|
void SvnActions::getaddedItems(const QString&path,svn::StatusEntries&target)
|
||
|
{
|
||
|
helpers::ValidRemoteOnly vro;
|
||
|
m_Data->m_UpdateCache.listsubs_if(path,vro);
|
||
|
target=vro.liste();
|
||
|
}
|
||
|
|
||
|
bool SvnActions::checkUpdatesRunning()
|
||
|
{
|
||
|
return m_UThread && m_UThread->running();
|
||
|
}
|
||
|
|
||
|
void SvnActions::addModifiedCache(const svn::StatusPtr&what)
|
||
|
{
|
||
|
if (what->textStatus()==svn_wc_status_conflicted) {
|
||
|
m_Data->m_conflictCache.insertKey(what,what->path());
|
||
|
} else {
|
||
|
m_Data->m_Cache.insertKey(what,what->path());
|
||
|
// m_Data->m_Cache.dump_tree();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void SvnActions::deleteFromModifiedCache(const QString&what)
|
||
|
{
|
||
|
m_Data->m_Cache.deleteKey(what,true);
|
||
|
m_Data->m_conflictCache.deleteKey(what,true);
|
||
|
//m_Data->m_Cache.dump_tree();
|
||
|
}
|
||
|
|
||
|
bool SvnActions::checkModifiedCache(const QString&path)
|
||
|
{
|
||
|
return m_Data->m_Cache.find(path);
|
||
|
}
|
||
|
|
||
|
bool SvnActions::checkReposLockCache(const QString&path)
|
||
|
{
|
||
|
return m_Data->m_repoLockCache.findSingleValid(path,false);
|
||
|
}
|
||
|
|
||
|
bool SvnActions::checkReposLockCache(const QString&path,svn::SharedPointer<svn::Status>&t)
|
||
|
{
|
||
|
/// @todo create a method where svn::Status* will be a parameter so no copy is needed but just reading content
|
||
|
return m_Data->m_repoLockCache.findSingleValid(path,t);
|
||
|
}
|
||
|
|
||
|
bool SvnActions::checkConflictedCache(const QString&path)
|
||
|
{
|
||
|
return m_Data->m_conflictCache.find(path);
|
||
|
}
|
||
|
|
||
|
void SvnActions::startFillCache(const QString&path)
|
||
|
{
|
||
|
stopFillCache();
|
||
|
svn::InfoEntry e;
|
||
|
if (!doNetworking()) {
|
||
|
emit sendNotify(i18n("Not filling logcache because networking is disabled"));
|
||
|
return;
|
||
|
}
|
||
|
if (!singleInfo(path,svn::Revision::UNDEFINED,e)) {
|
||
|
return;
|
||
|
}
|
||
|
if (svn::Url::isLocal(e.reposRoot())) {
|
||
|
return;
|
||
|
}
|
||
|
m_FCThread=new FillCacheThread(this,e.reposRoot());
|
||
|
m_FCThread->start();
|
||
|
emit sendNotify(i18n("Filling log cache in background"));
|
||
|
}
|
||
|
|
||
|
bool SvnActions::doNetworking()
|
||
|
{
|
||
|
// if networking is allowd we don't need extra checks, second is just for avoiding segfaults
|
||
|
if (Kdesvnsettings::network_on()||!m_Data->m_ParentList) {
|
||
|
return true;
|
||
|
}
|
||
|
bool is_url=false;
|
||
|
if (m_Data->m_ParentList->isNetworked()) {
|
||
|
// if called http:// etc.pp.
|
||
|
is_url=true;
|
||
|
} else if (m_Data->m_ParentList->baseUri().startsWith("/")){
|
||
|
// if opened a working copy we must check if it points to a networking repository
|
||
|
svn::InfoEntry e;
|
||
|
if (!singleInfo(m_Data->m_ParentList->baseUri(),svn::Revision::UNDEFINED,e)) {
|
||
|
return false;
|
||
|
}
|
||
|
is_url = !e.reposRoot().startsWith("file:/");
|
||
|
}
|
||
|
return !is_url;
|
||
|
}
|
||
|
|
||
|
void SvnActions::customEvent(QCustomEvent * e)
|
||
|
{
|
||
|
if (e->type()==EVENT_LOGCACHE_FINISHED) {
|
||
|
emit sendNotify(i18n("Filling log cache in background finished."));
|
||
|
stopFillCache();
|
||
|
emit sigThreadsChanged();
|
||
|
return;
|
||
|
} else if (e&&e->type()==EVENT_LOGCACHE_STATUS && m_FCThread && m_FCThread->running()) {
|
||
|
FillCacheStatusEvent*fev=(FillCacheStatusEvent*)e;
|
||
|
emit sigCacheStatus(fev->current(),fev->max());
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/*!
|
||
|
\fn SvnActions::createUpdateCache(const QString&what)
|
||
|
*/
|
||
|
bool SvnActions::createUpdateCache(const QString&what)
|
||
|
{
|
||
|
clearUpdateCache();
|
||
|
m_Data->m_repoLockCache.clear();
|
||
|
stopCheckUpdateThread();
|
||
|
if (!doNetworking()) {
|
||
|
emit sendNotify(i18n("Not checking for updates because networking is disabled"));
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
m_UThread = new CheckModifiedThread(this,what,true);
|
||
|
m_UThread->start();
|
||
|
m_Data->m_UpdateCheckTimer.start(100,true);
|
||
|
emit sendNotify(i18n("Checking for updates started in background"));
|
||
|
m_Data->m_UpdateCheckTick.start();
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
bool SvnActions::checkUpdateCache(const QString&path)const
|
||
|
{
|
||
|
return m_Data->m_UpdateCache.find(path);
|
||
|
}
|
||
|
|
||
|
void SvnActions::removeFromUpdateCache(const QStringList&what,bool exact_only)
|
||
|
{
|
||
|
for (unsigned int i = 0; i < what.count(); ++i) {
|
||
|
m_Data->m_UpdateCache.deleteKey(what[i],exact_only);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
bool SvnActions::isUpdated(const QString&path)const
|
||
|
{
|
||
|
svn::SharedPointer<svn::Status> d;
|
||
|
return m_Data->m_UpdateCache.findSingleValid(path,d);
|
||
|
}
|
||
|
|
||
|
bool SvnActions::getUpdated(const QString&path,svn::SharedPointer<svn::Status>&d)const
|
||
|
{
|
||
|
return m_Data->m_UpdateCache.findSingleValid(path,d);
|
||
|
}
|
||
|
|
||
|
void SvnActions::clearUpdateCache()
|
||
|
{
|
||
|
m_Data->m_UpdateCache.clear();
|
||
|
}
|
||
|
|
||
|
/*!
|
||
|
\fn SvnActions::makeIgnoreEntry(const QString&which)
|
||
|
*/
|
||
|
bool SvnActions::makeIgnoreEntry(SvnItem*which,bool unignore)
|
||
|
{
|
||
|
if (!which) return false;
|
||
|
QString parentName = which->getParentDir();
|
||
|
if (parentName.isEmpty()) return false;
|
||
|
QString name = which->shortName();
|
||
|
QString ex;
|
||
|
svn::Path p(parentName);
|
||
|
svn::Revision r(svn_opt_revision_unspecified);
|
||
|
|
||
|
QPair<QLONG,svn::PathPropertiesMapList> pmp;
|
||
|
try {
|
||
|
pmp = m_Data->m_Svnclient->propget("svn:ignore",p,r,r);
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return false;
|
||
|
}
|
||
|
svn::PathPropertiesMapList pm = pmp.second;
|
||
|
QString data = "";
|
||
|
if (pm.size()>0) {
|
||
|
svn::PropertiesMap&mp = pm[0].second;
|
||
|
data = mp["svn:ignore"];
|
||
|
}
|
||
|
bool result = false;
|
||
|
QStringList lst = QStringList::split("\n",data);
|
||
|
QStringList::iterator it = lst.find(name);
|
||
|
if (it != lst.end()) {
|
||
|
if (unignore) {
|
||
|
lst.erase(it);
|
||
|
result = true;
|
||
|
}
|
||
|
} else {
|
||
|
if (!unignore) {
|
||
|
lst.append(name);
|
||
|
result = true;
|
||
|
}
|
||
|
}
|
||
|
if (result) {
|
||
|
data = lst.join("\n");
|
||
|
try {
|
||
|
m_Data->m_Svnclient->propset("svn:ignore",data,p);
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
svn::PathPropertiesMapListPtr SvnActions::propList(const QString&which,const svn::Revision&where,bool cacheOnly)
|
||
|
{
|
||
|
svn::PathPropertiesMapListPtr pm;
|
||
|
if (!which.isEmpty()) {
|
||
|
QString fk=where.toString()+"/"+which;
|
||
|
QString ex;
|
||
|
svn::Path p(which);
|
||
|
|
||
|
if (where != svn::Revision::WORKING)
|
||
|
{
|
||
|
m_Data->m_PropertiesCache.findSingleValid(fk,pm);
|
||
|
}
|
||
|
if (!pm && !cacheOnly)
|
||
|
{
|
||
|
try {
|
||
|
pm = m_Data->m_Svnclient->proplist(p,where,where);
|
||
|
} catch (const svn::Exception&e) {
|
||
|
/* no messagebox needed */
|
||
|
if (e.apr_err()!=SVN_ERR_WC_NOT_DIRECTORY) {
|
||
|
sendNotify(e.msg());
|
||
|
}
|
||
|
}
|
||
|
if (where != svn::Revision::WORKING && pm) {
|
||
|
kdDebug()<<"Put into cache "<<endl;
|
||
|
m_Data->m_PropertiesCache.insertKey(pm,fk);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
return pm;
|
||
|
}
|
||
|
|
||
|
bool SvnActions::isLockNeeded(SvnItem*which,const svn::Revision&where)
|
||
|
{
|
||
|
if (!which) return false;
|
||
|
QString ex;
|
||
|
svn::Path p(which->fullName());
|
||
|
|
||
|
QPair<QLONG,svn::PathPropertiesMapList> pmp;
|
||
|
try {
|
||
|
pmp = m_Data->m_Svnclient->propget("svn:needs-lock",p,where,where);
|
||
|
} catch (const svn::Exception&e) {
|
||
|
/* no messagebox needed */
|
||
|
//emit clientException(e.msg());
|
||
|
return false;
|
||
|
}
|
||
|
svn::PathPropertiesMapList pm = pmp.second;
|
||
|
if (pm.size()>0) {
|
||
|
svn::PropertiesMap&mp = pm[0].second;
|
||
|
if (mp.find("svn:needs-lock")!=mp.end()) {
|
||
|
return true;
|
||
|
}
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
QString SvnActions::searchProperty(QString&Store, const QString&property, const QString&start,const svn::Revision&where,bool up)
|
||
|
{
|
||
|
svn::Path pa(start);
|
||
|
kdDebug()<<"Url? "<<pa.isUrl()<<endl;
|
||
|
svn::InfoEntry inf;
|
||
|
|
||
|
if (!singleInfo(start,where,inf)) {
|
||
|
return QString::null;
|
||
|
}
|
||
|
while(pa.length()>0) {
|
||
|
svn::PathPropertiesMapListPtr pm = propList(pa,where,false);
|
||
|
if (!pm) {
|
||
|
return QString::null;
|
||
|
}
|
||
|
if (pm->size()>0) {
|
||
|
svn::PropertiesMap&mp = (*pm)[0].second;
|
||
|
if (mp.find(property)!=mp.end()) {
|
||
|
Store=mp[property];
|
||
|
return pa;
|
||
|
}
|
||
|
}
|
||
|
if (up) {
|
||
|
pa.removeLast();
|
||
|
kdDebug()<<"Going up to " << pa.path() << endl;
|
||
|
if (pa.isUrl() && inf.reposRoot().length()>pa.path().length()) {
|
||
|
kdDebug()<<pa.path()<<" is not in repository" << endl;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
} else {
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
return QString::null;
|
||
|
}
|
||
|
|
||
|
bool SvnActions::makeList(const QString&url,svn::DirEntries&dlist,svn::Revision&where,bool rec)
|
||
|
{
|
||
|
if (!m_Data->m_CurrentContext) return false;
|
||
|
QString ex;
|
||
|
try {
|
||
|
dlist = m_Data->m_Svnclient->list(url,where,where,rec?svn::DepthInfinity:svn::DepthEmpty,false);
|
||
|
} catch (const svn::Exception&e) {
|
||
|
emit clientException(e.msg());
|
||
|
return false;
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
/*!
|
||
|
\fn SvnActions::isLocalWorkingCopy(const KURL&url)
|
||
|
*/
|
||
|
bool SvnActions::isLocalWorkingCopy(const KURL&url,QString&_baseUri)
|
||
|
{
|
||
|
if (url.isEmpty()||!url.isLocalFile()) return false;
|
||
|
QString cleanpath = url.path();
|
||
|
while (cleanpath.endsWith("/")) {
|
||
|
cleanpath.truncate(cleanpath.length()-1);
|
||
|
}
|
||
|
_baseUri="";
|
||
|
svn::Revision peg(svn_opt_revision_unspecified);
|
||
|
svn::Revision rev(svn_opt_revision_unspecified);
|
||
|
svn::InfoEntries e;
|
||
|
try {
|
||
|
e = m_Data->m_Svnclient->info(cleanpath,svn::DepthEmpty,rev,peg);
|
||
|
} catch (const svn::Exception&e) {
|
||
|
kdDebug()<< e.msg()<< " " << endl;
|
||
|
if (SVN_ERR_WC_NOT_DIRECTORY==e.apr_err())
|
||
|
{
|
||
|
return false;
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
_baseUri=e[0].url();
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
void SvnActions::slotExtraLogMsg(const QString&msg)
|
||
|
{
|
||
|
emit sigExtraLogMsg(msg);
|
||
|
}
|
||
|
|
||
|
void SvnActions::slotCancel(bool how)
|
||
|
{
|
||
|
if (!m_Data->m_CurrentContext) return;
|
||
|
m_Data->m_SvnContextListener->setCanceled(how);
|
||
|
}
|
||
|
|
||
|
void SvnActions::setContextData(const QString&aKey,const QString&aValue)
|
||
|
{
|
||
|
if (aValue.isNull()) {
|
||
|
QMap<QString,QString>::iterator it = m_Data->m_contextData.find(aKey);
|
||
|
if (it!=m_Data->m_contextData.end()) {
|
||
|
m_Data->m_contextData.remove(it);
|
||
|
}
|
||
|
} else {
|
||
|
m_Data->m_contextData[aKey]=aValue;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void SvnActions::clearContextData()
|
||
|
{
|
||
|
m_Data->m_contextData.clear();
|
||
|
}
|
||
|
|
||
|
QString SvnActions::getContextData(const QString&aKey)const
|
||
|
{
|
||
|
if (m_Data->m_contextData.find(aKey)!=m_Data->m_contextData.end()) {
|
||
|
return m_Data->m_contextData[aKey];
|
||
|
}
|
||
|
return QString::null;
|
||
|
}
|
||
|
|
||
|
bool SvnActions::threadRunning(ThreadType which)
|
||
|
{
|
||
|
switch(which) {
|
||
|
case checkupdatethread:
|
||
|
return (m_UThread && m_UThread->running());
|
||
|
break;
|
||
|
case fillcachethread:
|
||
|
return (m_FCThread && m_FCThread->running());
|
||
|
break;
|
||
|
case checkmodifiedthread:
|
||
|
return (m_CThread && m_CThread->running());
|
||
|
break;
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
#include "svnactions.moc"
|