summaryrefslogtreecommitdiffstats
path: root/quanta/project/projectprivate.cpp
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commite9ae80694875f869892f13f4fcaf1170a00dea41 (patch)
treeaa2f8d8a217e2d376224c8d46b7397b68d35de2d /quanta/project/projectprivate.cpp
downloadtdewebdev-e9ae80694875f869892f13f4fcaf1170a00dea41.tar.gz
tdewebdev-e9ae80694875f869892f13f4fcaf1170a00dea41.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdewebdev@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'quanta/project/projectprivate.cpp')
-rw-r--r--quanta/project/projectprivate.cpp1675
1 files changed, 1675 insertions, 0 deletions
diff --git a/quanta/project/projectprivate.cpp b/quanta/project/projectprivate.cpp
new file mode 100644
index 00000000..c74b1dc9
--- /dev/null
+++ b/quanta/project/projectprivate.cpp
@@ -0,0 +1,1675 @@
+/***************************************************************************
+ projectprivate.cpp - description
+ -------------------
+ begin : Mon Oct 4 20:49:39 2004
+ copyright : (C) 2000 by Yacovlev Alexander & Dmitry Poplavsky <pdima@mail.univ.kiev.ua>
+ (C) 2001-2004 by Andras Mantia <amantia@kde.org>
+ ***************************************************************************/
+
+/***************************************************************************
+ * *
+ * This program is free software; you can redistribute it and/or modify *
+ * it under the terms of the GNU General Public License as published by *
+ * the Free Software Foundation; either version 2 of the License, or *
+ * (at your option) any later version. *
+ * *
+ ***************************************************************************/
+
+#include "projectprivate.h"
+
+//qt includes
+#include <qcheckbox.h>
+#include <qdir.h>
+#include <qfile.h>
+#include <qradiobutton.h>
+#include <qwidgetstack.h>
+#include <qwizard.h>
+#include <qeventloop.h>
+
+//kde includes
+#include <kaction.h>
+#include <kapplication.h>
+#include <kcharsets.h>
+#include <kconfig.h>
+#include <kdirwatch.h>
+#include <kfiledialog.h>
+#include <kinputdialog.h>
+#include <kio/netaccess.h>
+#include <klineedit.h>
+#include <klocale.h>
+#include <kmainwindow.h>
+#include <kmessagebox.h>
+#include <kparts/componentfactory.h>
+#include <kprogress.h>
+#include <kstandarddirs.h>
+#include <ktempfile.h>
+#include <kurl.h>
+#include <kurlrequester.h>
+#include <kurlrequesterdlg.h>
+
+//app includes
+#include "copyto.h"
+#include "debuggerclient.h"
+#include "dtds.h"
+#include "project.h"
+#include "projectnewgeneral.h"
+#include "projectnewlocal.h"
+#include "projectnewweb.h"
+#include "projectnewfinal.h"
+#include "qpevents.h"
+#include "quantacommon.h"
+#include "resource.h"
+#include "uploadprofiles.h"
+#include "viewmanager.h"
+
+ProjectPrivate::ProjectPrivate(Project *p)
+ : QObject(), config(0L), m_dirWatch(0L), tempFile(0L), sessionTempFile(0L)
+{
+ parent = p;
+ m_projectFiles.setAutoDelete(true);
+ m_showUploadTreeviews = true;
+ m_eventsEnabled = true;
+ m_events = new EventActions();
+ init();
+ m_wizTitle = i18n("<b>Insert Files in Project</b>");
+}
+
+ProjectPrivate::~ProjectPrivate()
+{
+ delete m_events;
+}
+
+/** setup of the actions */
+void ProjectPrivate::initActions(KActionCollection *ac)
+{
+ (void) new KAction( i18n( "&New Project..." ), "window_new", 0,
+ this, SLOT( slotNewProject() ),
+ ac, "project_new" );
+
+ (void) new KAction( i18n( "&Open Project..." ), "project_open", 0,
+ this, SLOT( slotOpenProject() ),
+ ac, "project_open" );
+ m_projectRecent =
+ KStdAction::openRecent(parent, SLOT(slotOpenProject(const KURL&)),
+ ac, "project_open_recent");
+ m_projectRecent->setText(i18n("Open Recent Project"));
+ m_projectRecent->setIcon("project_open");
+ m_projectRecent->setToolTip(i18n("Open/Open recent project"));
+ connect(m_projectRecent, SIGNAL(activated()), this, SLOT(slotOpenProject()));
+
+ closeprjAction = new KAction( i18n( "&Close Project" ), "fileclose", 0,
+ this, SLOT( slotCloseProject() ),
+ ac, "project_close" );
+
+
+ openPrjViewAction = new KSelectAction( i18n( "Open Project &View..." ), 0,
+ ac, "project_view_open" );
+ connect(openPrjViewAction, SIGNAL(activated(const QString &)),
+ this, SLOT(slotOpenProjectView(const QString &)));
+ openPrjViewAction->setToolTip(i18n("Open project view"));
+
+ savePrjViewAction = new KAction( i18n( "&Save Project View" ), "filesave", 0,
+ this, SLOT( slotSaveProjectView() ),
+ ac, "project_view_save" );
+ saveAsPrjViewAction = new KAction( i18n( "Save Project View &As..." ), "filesaveas", 0,
+ this, SLOT( slotSaveAsProjectView() ),
+ ac, "project_view_save_as" );
+ deletePrjViewAction = new KSelectAction( i18n( "&Delete Project View" ), "editdelete", 0,
+ ac, "project_view_delete" );
+ connect(deletePrjViewAction, SIGNAL(activated(const QString &)),
+ this, SLOT(slotDeleteProjectView(const QString &)));
+ deletePrjViewAction->setToolTip(i18n("Close project view"));
+
+
+
+ insertFileAction = new KAction( i18n( "&Insert Files..." ), 0,
+ this, SLOT( slotAddFiles() ),
+ ac, "project_insert_file" );
+
+ insertDirAction = new KAction( i18n( "Inser&t Folder..." ), 0,
+ this, SLOT( slotAddDirectory() ),
+ ac, "project_insert_directory" );
+
+ rescanPrjDirAction = new KAction( i18n( "&Rescan Project Folder..." ), "reload", 0,
+ parent, SLOT( slotRescanPrjDir() ),
+ ac, "project_rescan" );
+
+ uploadProjectAction = new KAction( i18n( "&Upload Project..." ), "up", Key_F8,
+ parent, SLOT( slotUpload() ),
+ ac, "project_upload" );
+
+ projectOptionAction = new KAction( i18n( "&Project Properties" ), "configure", SHIFT + Key_F7,
+ parent, SLOT( slotOptions() ),
+ ac, "project_options" );
+
+ saveAsProjectTemplateAction =
+ new KAction( i18n( "Save as Project Template..." ), 0,
+ m_mainWindow, SLOT( slotFileSaveAsProjectTemplate() ),
+ ac, "save_project_template" );
+
+ saveSelectionAsProjectTemplateAction =
+ new KAction( i18n( "Save Selection to Project Template File..." ), 0,
+ m_mainWindow, SLOT( slotFileSaveSelectionAsProjectTemplate() ),
+ ac, "save_selection_project_template" );
+ adjustActions();
+}
+
+
+void ProjectPrivate::adjustActions()
+{
+ bool projectExists = parent->hasProject();
+ closeprjAction->setEnabled(projectExists);
+ openPrjViewAction->setEnabled(projectExists);
+ savePrjViewAction->setEnabled(projectExists);
+ saveAsPrjViewAction->setEnabled(projectExists);
+ deletePrjViewAction->setEnabled(projectExists);
+
+ insertFileAction->setEnabled(projectExists);
+ insertDirAction->setEnabled(projectExists);
+ rescanPrjDirAction->setEnabled(projectExists);
+ uploadProjectAction->setEnabled(projectExists);
+ projectOptionAction->setEnabled(projectExists);
+ saveAsProjectTemplateAction->setEnabled(projectExists);
+ saveSelectionAsProjectTemplateAction->setEnabled(projectExists);
+
+ adjustViewActions();
+ parent->slotShowProjectToolbar(projectExists);
+}
+
+
+void ProjectPrivate::adjustViewActions()
+{
+ QStringList viewList = projectViewList();
+ QString oldItem = openPrjViewAction->currentText();
+ openPrjViewAction->clear();
+ openPrjViewAction->setItems(viewList);
+ int i = viewList.findIndex(oldItem);
+ if (i > -1)
+ openPrjViewAction->setCurrentItem(i);
+ deletePrjViewAction->clear();
+ deletePrjViewAction->setItems(viewList);
+ bool hasView = !currentProjectView.isEmpty();
+ savePrjViewAction->setEnabled(hasView);
+}
+
+
+QStringList ProjectPrivate::projectViewList()
+{
+ QStringList list;
+ QDomNodeList nl = dom.elementsByTagName("projectview");
+ QDomElement el;
+ for (uint i = 0; i < nl.count(); i++)
+ {
+ el = nl.item(i).cloneNode().toElement();
+ list += el.attribute("name");
+ }
+ list.sort();
+ return list;
+}
+
+void ProjectPrivate::init()
+{
+ projectURL = KURL();
+ templateURL = KURL();
+ projectName = QString::null;
+ m_modified = false;
+ m_defaultDTD = qConfig.defaultDocType;
+ excludeRx.setPattern(".*~$");
+ excludeList.clear();
+ excludeList.append("*~");
+ usePreviewPrefix = false;
+ previewPrefix = KURL();
+ m_persistentBookmarks = false;
+ m_debuggerPersistentBreakpoints = false;
+ m_debuggerPersistentWatches = false;
+ m_excludeCvsignore = false;
+ currentProjectView = QString::null;
+ m_projectFiles.clear();
+ m_mailingList = QString::null;
+ m_teamLeader.name = QString::null;
+ m_teamLeader.email = QString::null;
+ m_taskLeaders.clear();
+ m_subprojectLeaders.clear();
+ m_subprojects.clear();
+ m_simpleMembers.clear();
+ UploadProfiles::ref()->clear();
+}
+
+
+void ProjectPrivate::openCurrentView()
+{
+ if (currentProjectView.isEmpty())
+ return;
+ KURL::List urlsToOpen, urlsInView;
+ QDomNodeList nl = dom.elementsByTagName("projectview");
+ QDomElement el;
+ for (uint i = 0; i < nl.count(); i++)
+ {
+ el = nl.item(i).cloneNode().toElement();
+ if (el.attribute("name") == currentProjectView)
+ {
+ QDomNodeList itemNodes = el.childNodes();
+ for (uint j = 0; j < itemNodes.count(); j++)
+ {
+ QDomElement el2 = itemNodes.item(j).cloneNode().toElement();
+ KURL url = baseURL;
+ QuantaCommon::setUrl(url,el2.attribute("url"));
+ url = QExtFileInfo::toAbsolute(url, baseURL);
+ if (el2.nodeName() == "viewitem")
+ {
+ urlsInView.append(url);
+ if (!ViewManager::ref()->isOpened(url) && QExtFileInfo::exists(url, true, m_mainWindow))
+ urlsToOpen.append(url);
+ } else {
+ if (el2.nodeName() == "viewtoolbar")
+ {
+ parent->loadToolbarFile(url);
+ }
+ }
+ }
+ // first we open what we want, might be that a wanted file is already open!
+ parent->openFiles(urlsToOpen, m_defaultEncoding);
+ // second we close what we don't want
+ KURL::List openURLs = ViewManager::ref()->openedFiles(true); // get open urls
+ KURL::List::Iterator it;
+ for ( it = openURLs.begin(); it != openURLs.end(); ++it )
+ {
+ if (urlsInView.findIndex( *it ) == -1)
+ parent->closeFile (*it);
+ }
+ break;
+ }
+ }
+ QStringList viewList = projectViewList();
+ int i = viewList.findIndex(currentProjectView);
+ if (i > -1)
+ openPrjViewAction->setCurrentItem(i);
+ adjustViewActions();
+}
+
+/** Opens a project view (toolbars & files). */
+void ProjectPrivate::slotOpenProjectView(const QString &view)
+{
+ currentProjectView = view;
+ openCurrentView();
+}
+
+/** insert files */
+void ProjectPrivate::insertFiles( KURL::List files )
+{
+ QDomElement el;
+ QDomNodeList nl = dom.elementsByTagName("item");
+ parent->statusMsg( i18n("Adding files to the project...") );
+ progressBar->setTotalSteps(2 * files.count() - 2);
+ progressBar->setValue(0);
+ progressBar->setTextEnabled(true);
+
+ KURL::List::Iterator it;
+ for ( it = files.begin(); it != files.end(); ++it )
+ {
+ if (m_projectFiles.contains(*it))
+ {
+ it = files.erase(it);
+ --it;
+ }
+ progressBar->advance(1);
+ }
+ for ( it = files.begin(); it != files.end(); ++it )
+ {
+ if (! (*it).isEmpty())
+ {
+ KURL url = *it;
+ url.setPath(url.directory(false));
+ while ( baseURL.isParentOf(url) )
+ {
+ if (!m_projectFiles.contains(url))
+ {
+ el = dom.createElement("item");
+ el.setAttribute("url", QuantaCommon::qUrl(QExtFileInfo::toRelative(url, baseURL, false)));
+ dom.firstChild().firstChild().appendChild(el);
+ m_projectFiles.insert( new ProjectURL(url, "", 1, false, el) );
+ emit eventHappened("after_project_add", url.url(), QString::null);
+ m_modified = true;
+ }
+ url.setPath(url.directory(false));
+ }
+ el = dom.createElement("item");
+ url = *it;
+ if (!excludeRx.exactMatch(url.path()))
+ {
+ el.setAttribute("url", QuantaCommon::qUrl(QExtFileInfo::toRelative(url, baseURL, false)));
+ dom.firstChild().firstChild().appendChild(el);
+ m_projectFiles.insert( new ProjectURL(url, "", 1, false, el) );
+ emit eventHappened("after_project_add", url.url(), QString::null);
+ m_modified = true;
+ }
+ }
+ progressBar->advance(1);
+ }
+ progressBar->setTotalSteps(1);
+ progressBar->setValue(0);
+ progressBar->setTextEnabled(false);
+
+ parent->reloadTree(&(m_projectFiles), false, QStringList());
+ parent->newStatus();
+ parent->statusMsg(QString::null);
+}
+
+
+/** insert files from dir recursive */
+void ProjectPrivate::insertFiles(const KURL& pathURL, const QString& mask )
+{
+ KURL::List list;
+
+ list.append(pathURL);
+ list += QExtFileInfo::allFiles(pathURL, mask, m_mainWindow);
+ insertFiles(list);
+}
+
+
+void ProjectPrivate::loadProjectXML()
+{
+//TODO: Optimize reading. For example iterate through all the nodes and handle them
+//according to the found node type
+ parent->statusMsg( i18n("Reading the project file...") );
+ QDomNode no;
+ QDomElement el;
+ KURL url;
+ QDomNode projectNode = dom.firstChild().firstChild();
+ projectName = projectNode.toElement().attribute("name");
+
+ if ( projectNode.isNull() || projectName.isEmpty() )
+ {
+ parent->hideSplash();
+ KMessageBox::sorry(m_mainWindow, i18n("Invalid project file.") );
+ adjustActions();
+ return;
+ }
+
+ m_modified = false;
+ QString tmpString;
+ QDomNode sessionNode;
+
+ if (!m_createSessionDom)
+ {
+ sessionNode = m_sessionDom.firstChild().firstChild();
+ tmpString = sessionNode.toElement().attribute("previewPrefix");
+ if ( !tmpString.isEmpty())
+ {
+ previewPrefix = KURL::fromPathOrURL(tmpString);
+ }
+ usePreviewPrefix = ( sessionNode.toElement().attribute("usePreviewPrefix") == "1");
+ m_persistentBookmarks = (sessionNode.toElement().attribute("usePersistentBookmarks") == "1");
+ } else //TODO: Remove when upgrade from 3.4 is not supported
+ {
+ tmpString = projectNode.toElement().attribute("previewPrefix");
+ if ( !tmpString.isEmpty())
+ {
+ previewPrefix = KURL::fromPathOrURL(tmpString);
+ }
+ usePreviewPrefix = ( projectNode.toElement().attribute("usePreviewPrefix") == "1");
+ m_persistentBookmarks = (projectNode.toElement().attribute("usePersistentBookmarks") == "1");
+
+ sessionNode = m_sessionDom.firstChild().firstChild();
+ sessionNode.toElement().setAttribute("usePreviewPrefix", usePreviewPrefix ? "1" : "0");
+ sessionNode.toElement().setAttribute("previewPrefix", previewPrefix.url());
+ sessionNode.toElement().setAttribute("usePersistentBookmarks", m_persistentBookmarks ? "1" : "0");
+ }
+ no = sessionNode.namedItem("itemcursorpositions");
+ if (no.isNull())
+ {
+ el = m_sessionDom.createElement("itemcursorpositions");
+ sessionNode.appendChild(el);
+ }
+ m_eventsEnabled = projectNode.toElement().attribute("enableEvents", "true") == "true";
+ m_defaultEncoding = projectNode.toElement().attribute("encoding");
+ if (m_defaultEncoding.isEmpty())
+ {
+ m_defaultEncoding = qConfig.defaultEncoding;
+ }
+ no = projectNode.namedItem("author");
+ author = no.firstChild().nodeValue();
+ no = projectNode.namedItem("email");
+ email = no.firstChild().nodeValue();
+ no = projectNode.namedItem("defaultDTD");
+ m_defaultDTD = no.firstChild().nodeValue();
+ if (m_defaultDTD.isEmpty()) m_defaultDTD = qConfig.defaultDocType;
+
+ no = projectNode.namedItem("autoload");
+ currentProjectView = no.toElement().attribute("projectview");
+ if (currentProjectView.isEmpty())
+ {
+ QStringList list = projectViewList();
+ if (list.count() > 0)
+ currentProjectView = list[0];
+ }
+ // Debugger
+ no = projectNode.namedItem("debuggerclient");
+ debuggerClient = no.firstChild().nodeValue();
+ m_debuggerPersistentBreakpoints = (no.toElement().attribute("persistentBreakpoints") == "1");
+ m_debuggerPersistentWatches = (no.toElement().attribute("persistentWatches") == "1");
+
+ no = projectNode.namedItem("templates");
+ tmpString = no.firstChild().nodeValue();
+ templateURL = baseURL;
+ if(no.isNull()) // compatability
+ {
+ templateURL.setPath("templates/");
+ m_modified = true;
+ }
+ else
+ {
+ QuantaCommon::setUrl(templateURL, tmpString);
+ }
+ if (tmpString != QuantaCommon::qUrl(templateURL) )
+ {
+ el = no.toElement();
+ url = QExtFileInfo::toRelative(templateURL, baseURL);
+ if(el.isNull())
+ {
+ el = dom.createElement("templates");
+ dom.firstChild().firstChild().appendChild(el);
+ el.appendChild(dom.createTextNode(QuantaCommon::qUrl(url)));
+ }
+ else
+ {
+ el.firstChild().setNodeValue(QuantaCommon::qUrl(url));
+ }
+ }
+ templateURL = QExtFileInfo::toAbsolute(templateURL, baseURL);
+
+ no = projectNode.namedItem("toolbars");
+ toolbarURL = baseURL;
+ if (no.isNull()) // compatability
+ {
+ toolbarURL.setPath(baseURL.path(1) + "toolbars/");
+ m_modified = true;
+ }
+ else
+ {
+ QuantaCommon::setUrl(toolbarURL,no.firstChild().nodeValue());
+ }
+ if (tmpString != QuantaCommon::qUrl(toolbarURL))
+ {
+ el = no.toElement();
+ url = QExtFileInfo::toRelative(toolbarURL, baseURL);
+ if(el.isNull())
+ {
+ el = dom.createElement("toolbars");
+ dom.firstChild().firstChild().appendChild(el);
+ el.appendChild(dom.createTextNode(QuantaCommon::qUrl(url)));
+ }
+ else
+ {
+ el.firstChild().setNodeValue(QuantaCommon::qUrl(url));
+ }
+ }
+ toolbarURL = QExtFileInfo::toAbsolute(toolbarURL, baseURL);
+
+ no = projectNode.namedItem("exclude");
+ m_excludeCvsignore = (no.toElement().attribute("cvsignore", "false") == "true");
+ QString excludeStr = no.firstChild().nodeValue();
+ QString regExpStr = "";
+ excludeList = QStringList::split(';', excludeStr);
+ for (uint i = 0; i < excludeList.count(); i++)
+ {
+ excludeStr = excludeList[i].stripWhiteSpace();
+ QString str = excludeStr;
+ if (!excludeStr.startsWith("*"))
+ {
+ if (!excludeStr.endsWith("*"))
+ str += "|^" + excludeStr + "/*|*/" + excludeStr + "/*|*/" + excludeStr + "$";
+ else
+ str += "|^" + excludeStr + "|*/" + excludeStr + "$";
+ } else
+ if (!excludeStr.endsWith("*"))
+ str = excludeStr + "/*|"+ excludeStr + "$";
+ str.replace(".","\\.");
+ str.replace("*",".*");
+ str.replace("?",".");
+ regExpStr.append(str);
+ if (i+1 < excludeList.count())
+ regExpStr.append("|");
+ }
+ QDomNodeList nl = dom.firstChild().firstChild().childNodes();
+ if (m_excludeCvsignore && projectURL.isLocalFile())
+ {
+ QStringList cvsIgnoreList;
+ uint nlCount = nl.count();
+ for ( uint i = 0; i < nlCount; i++ )
+ {
+ el = nl.item(i).toElement();
+ tmpString = el.attribute("url");
+ if (!tmpString.endsWith("/")) continue;
+ cvsIgnoreList.append(tmpString);
+ }
+ cvsIgnoreList.append("");
+ for (QStringList::ConstIterator it = cvsIgnoreList.constBegin(); it != cvsIgnoreList.constEnd(); ++it)
+ {
+ tmpString = *it;
+ QString rxStr;
+ KURL cvsIgnoreURL;
+ cvsIgnoreURL.setPath(baseURL.path(1) + tmpString + ".cvsignore");
+ QFile f(cvsIgnoreURL.path());
+ if (f.open(IO_ReadOnly))
+ {
+ QTextStream stream(&f);
+ stream.setEncoding(QTextStream::UnicodeUTF8);
+ QString line;
+ while (!stream.atEnd())
+ {
+ line = stream.readLine().stripWhiteSpace();
+ line.prepend(tmpString);
+ if (!line.endsWith("*"))
+ line = line + "/*|"+ line + "$";
+ if (!line.startsWith("*"))
+ line.prepend("^");
+ line.replace(".","\\.");
+ line.replace("*",".*");
+ line.replace("?",".");
+ rxStr += line + "|";
+ }
+ regExpStr.prepend(rxStr);
+ f.close();
+ }
+ }
+ }
+ excludeRx.setPattern(regExpStr);
+
+ m_events->clear();
+ nl = projectNode.toElement().elementsByTagName("event");
+ uint nlCount = nl.count();
+ for ( uint i = 0; i < nlCount; i++ )
+ {
+ el = nl.item(i).toElement();
+ EventAction ev;
+ if (el.attribute("type", "internal") == "internal")
+ ev.type = EventAction::Internal;
+ else
+ ev.type = EventAction::External;
+ ev.action = el.attribute("action");
+ QDomNodeList nl2 = el.elementsByTagName("argument");
+ for (uint j = 0; j < nl2.count(); j++)
+ {
+ QString s = nl2.item(j).toElement().text();
+ if (s != "--not set--" && !s.isEmpty())
+ ev.arguments << s;
+ }
+ if (m_events->contains(el.attribute("name")))
+ {
+ (*m_events)[el.attribute("name")].append(ev);
+ } else
+ {
+ QValueList<EventAction> evList;
+ evList.append(ev);
+ m_events->insert(el.attribute("name"), evList);
+ }
+ }
+
+ QDomNode teamNode = projectNode.namedItem("teamdata");
+ no = teamNode.namedItem("leader");
+ if (!no.isNull())
+ {
+ m_teamLeader.name = no.namedItem("name").toElement().text();
+ m_teamLeader.nickName = no.namedItem("nickName").toElement().text();
+ m_teamLeader.email = no.namedItem("email").toElement().text();
+ }
+
+ m_subprojects.clear();
+ m_subprojectLeaders.clear();
+ no = teamNode.namedItem("subprojectleaders");
+ nl = no.toElement().elementsByTagName("subproject");
+ for (uint i = 0; i < nl.count(); i++)
+ {
+ el = nl.item(i).toElement();
+ QDomElement el2 = el.namedItem("subprojectleader").toElement();
+ TeamMember member;
+ member.name = el2.attribute("name");
+ member.nickName = el2.attribute("nickName");
+ member.email = el2.attribute("email");
+ SubProject subproject;
+ subproject.name = el.attribute("name");
+ subproject.location = el.attribute("location");
+ m_subprojects.append(subproject);
+ m_subprojectLeaders[subproject.name] = member;
+ }
+
+ m_taskLeaders.clear();
+ no = teamNode.namedItem("taskleaders");
+ nl = no.toElement().elementsByTagName("projecttask");
+ for (uint i = 0; i < nl.count(); i++)
+ {
+ el = nl.item(i).toElement();
+ TeamMember member;
+ member.name = el.attribute("tasklead");
+ member.nickName = el.attribute("nickName");
+ member.email = el.attribute("email");
+ m_taskLeaders[el.attribute("task")] = member;
+ }
+
+ m_simpleMembers.clear();
+ nl = teamNode.toElement().elementsByTagName("member");
+ for (uint i = 0; i < nl.count(); i++)
+ {
+ el = nl.item(i).toElement();
+ TeamMember member;
+ member.name = el.namedItem("name").toElement().text();
+ member.nickName = el.namedItem("nickName").toElement().text();
+ member.email = el.namedItem("email").toElement().text();
+ member.task = el.attribute("task");
+ m_simpleMembers.append(member);
+ }
+
+ no = teamNode.namedItem("mailinglist");
+ m_mailingList = no.toElement().attribute("address");
+ teamNode = m_sessionDom.firstChild().namedItem("teamdata");
+ m_yourself = teamNode.toElement().attribute("yourself");
+
+ if (m_projectFiles.readFromXML(dom, baseURL, templateURL, excludeRx))
+ m_modified = true;
+ QDomNode uploadNode;
+ if (!m_createSessionDom)
+ {
+ uploadNode = sessionNode.namedItem("uploadprofiles");
+ } else
+ {
+ uploadNode = projectNode.namedItem("uploadprofiles").cloneNode(true);
+ sessionNode.appendChild(uploadNode);
+ }
+
+ QDomElement uploadEl = uploadNode.toElement();
+ m_showUploadTreeviews = uploadEl.attribute("showtreeviews", "true") == "true";
+ if (m_showUploadTreeviews)
+ {
+ // read the profiles and create treeviews for them
+ UploadProfiles::ref()->readFromXML(m_sessionDom);
+ } else
+ UploadProfiles::ref()->clear();
+
+ if (m_createSessionDom)
+ {
+ QDomNode node;
+ node = projectNode.namedItem("treestatus").cloneNode(true);
+ sessionNode.appendChild(node);
+ node = projectNode.namedItem("debuggers").cloneNode(true);
+ sessionNode.appendChild(node);
+ }
+
+
+ parent->statusMsg(QString::null);
+ parent->newProjectLoaded(projectName, baseURL, templateURL);
+ parent->reloadTree(&(m_projectFiles), true, treeStatusFromXML());
+ parent->newStatus();
+ adjustActions();
+}
+
+void ProjectPrivate::slotAcceptCreateProject()
+{
+ bool errorOccured = false;
+
+ projectName = png->linePrjName->text();
+ QString basePath = png->linePrjDir ->text();
+
+ KURL oldBaseURL = baseURL;
+ baseURL = KURL::fromPathOrURL(basePath);
+ if (baseURL.isLocalFile())
+ {
+ QString path = QDir(baseURL.path()).canonicalPath();
+ if (baseURL.path().endsWith("/"))
+ path.append("/");
+ if (!path.isEmpty())
+ baseURL.setPath(path);
+ }
+ /*
+ it is important to set the fields only if there is some input
+ otherwise you set them to an empty string and the treeview will
+ not recognize it as parent url because:
+ QString::Null != ""
+ */
+ if (!png->lineHost->text().isEmpty())
+ baseURL.setHost(png->lineHost->text());
+ if (!png->lineUser->text().isEmpty())
+ baseURL.setUser(png->lineUser->text());
+ if (!png->linePasswd->text().isEmpty())
+ baseURL.setPass(png->linePasswd->text());
+ if (!png->linePort->text().isEmpty())
+ baseURL.setPort(png->linePort->text().toInt());
+ if (!png->comboProtocol->currentText().isEmpty())
+ baseURL.setProtocol(png->comboProtocol->currentText());
+ if (baseURL.protocol() == i18n("Local")) baseURL.setProtocol("file");
+ baseURL.adjustPath(1);
+ if (!baseURL.path().startsWith("/")) baseURL.setPath("/"+ baseURL.path());
+ if (!QExtFileInfo::createDir(baseURL, m_mainWindow))
+ {
+ QuantaCommon::dirCreationError(m_mainWindow, baseURL);
+ baseURL = oldBaseURL;
+ } else
+ {
+ projectURL = baseURL;
+ projectURL.setPath(baseURL.path(1) + png->linePrjFile->text());
+
+ errorOccured = !createEmptyDom();
+ if (!errorOccured)
+ {
+ email = pnf->lineEmail->text();
+ author = pnf->lineAuthor->text();
+ m_defaultDTD = DTDs::ref()->getDTDNameFromNickName(pnf->dtdCombo->currentText());
+ m_defaultEncoding = pnf->encodingCombo->currentText();
+
+ previewPrefix = KURL::fromPathOrURL( pnf->linePrefix->text() );
+ usePreviewPrefix = pnf->checkPrefix->isChecked();
+
+ QDomElement el;
+ KURL url;
+
+ el = dom.firstChild().firstChild().toElement();
+ el.setAttribute("type", png->type());
+ el.setAttribute("name", projectName );
+ el.setAttribute("encoding", m_defaultEncoding);
+
+ el = m_sessionDom.firstChild().firstChild().toElement();
+ el.setAttribute("previewPrefix", previewPrefix.url() );
+ el.setAttribute("usePreviewPrefix",usePreviewPrefix);
+
+ el = dom.createElement("author");
+ dom.firstChild().firstChild().appendChild( el );
+ el.appendChild( dom.createTextNode( author ) );
+
+ el = dom.createElement("email");
+ dom.firstChild().firstChild().appendChild( el );
+ el.appendChild( dom.createTextNode( email ) );
+
+ el = dom.createElement("defaultDTD");
+ dom.firstChild().firstChild().appendChild(el);
+ el.appendChild(dom.createTextNode(m_defaultDTD));
+
+ KURL::List list;
+ if ( png->type() == "Local" ) list = pnl->files();
+ if ( png->type() == "Web" ) list = pnw->files();
+
+ for ( KURL::List::Iterator it = list.begin(); it != list.end(); ++it )
+ {
+ url = *it;//QExtFileInfo::toRelative(*it, baseURL );
+ el = dom.createElement("item");
+ el.setAttribute("url",QuantaCommon::qUrl(url));
+ dom.firstChild().firstChild().appendChild( el );
+ }
+
+ // el = dom.createElement("item");
+ // el.setAttribute("url","templates/");
+ // dom.firstChild().firstChild().appendChild(el);
+
+ //setup the templates directory
+ templateURL = baseURL;
+ bool createTemplateDir = true;
+ if (pnf->insertGlobalTemplates->isChecked())
+ {
+ KURL url;
+ QuantaCommon::setUrl(url, qConfig.globalDataDir + resourceDir + "templates/");
+ parent->slotAddDirectory(url, false);
+ QuantaCommon::setUrl(templateURL, "templates/");
+ createTemplateDir = false;
+ }
+ if (pnf->insertLocalTemplates->isChecked())
+ {
+ KURL url;
+ QuantaCommon::setUrl(url, locateLocal("data", resourceDir + "templates/"));
+ parent->slotAddDirectory(url, false);
+ QuantaCommon::setUrl(templateURL, "templates/");
+ createTemplateDir = false;
+ }
+
+ if (createTemplateDir)
+ {
+ QuantaCommon::setUrl(templateURL, png->linePrjTmpl->text());
+ templateURL.adjustPath(1);
+ templateURL = QExtFileInfo::toAbsolute(templateURL, baseURL);
+ if (!QExtFileInfo::createDir(templateURL, m_mainWindow))
+ {
+ QuantaCommon::dirCreationError(m_mainWindow, templateURL);
+ }
+ }
+ //the nodes are already created in loadProjectXML() called from createEmptyDom()
+ el = dom.firstChild().firstChild().namedItem("templates").toElement();
+ url = QExtFileInfo::toRelative(templateURL, baseURL);
+ el.firstChild().setNodeValue(QuantaCommon::qUrl(url));
+
+ //setup the toolbars directory
+ toolbarURL = baseURL;
+ QuantaCommon::setUrl(toolbarURL,png->linePrjToolbar->text());
+ toolbarURL.adjustPath(1);
+ toolbarURL = QExtFileInfo::toAbsolute(toolbarURL, baseURL);
+ if (!QExtFileInfo::createDir(toolbarURL, m_mainWindow))
+ {
+ QuantaCommon::dirCreationError(m_mainWindow, toolbarURL);
+ }
+ el = dom.firstChild().firstChild().namedItem("toolbars").toElement();
+ url = QExtFileInfo::toRelative(toolbarURL, baseURL);
+ el.firstChild().setNodeValue(QuantaCommon::qUrl(url));
+
+#if KDE_IS_VERSION(3,4,89)
+ m_projectRecent->addURL(projectURL, projectName);
+#else
+ m_projectRecent->addURL(projectURL);
+#endif
+ m_projectRecent->setCurrentItem(0);
+ // remember the project in config
+ writeConfig();
+
+//workaround to load the newly created project items in the treeview
+ KURL u = projectURL;
+ slotCloseProject();
+ loadProject(u);
+ }
+}
+if (errorOccured)
+{
+ slotCloseProject();
+}
+}
+
+
+/** Saves a project view (group of files & toolbars) without asking for a name. */
+void ProjectPrivate::slotSaveProjectView()
+{
+ slotSaveAsProjectView(currentProjectView.isEmpty());
+}
+
+
+/** Deletes a project view */
+void ProjectPrivate::slotDeleteProjectView(const QString &view)
+{
+ QDomNodeList nl = dom.elementsByTagName("projectview");
+ QDomElement el;
+ for (uint i = 0; i < nl.count(); i++)
+ {
+ QDomNode node = nl.item(i);
+ el = node.cloneNode().toElement();
+ if (el.attribute("name") == view)
+ {
+ node.parentNode().removeChild(node);
+ if (currentProjectView == view)
+ currentProjectView = "";
+ parent->setModified();
+ adjustViewActions();
+ break;
+ }
+ }
+}
+
+/** Saves a project view (group of files & toolbars) asking for a name. */
+void ProjectPrivate::slotSaveAsProjectView(bool askForName)
+{
+ if (askForName)
+ {
+ bool ok;
+ QString newProjectView = KInputDialog::getText(i18n("Save Project View As"),
+ i18n("Enter the name of the view:"), "", &ok, m_mainWindow).lower();
+ if (!ok)
+ return;
+ currentProjectView = newProjectView;
+ }
+ QDomNodeList nl = dom.elementsByTagName("projectview");
+ for (uint i = 0 ;i < nl.count(); i++)
+ {
+ QDomNode node = nl.item(i);
+ if (node.toElement().attribute("name") == currentProjectView)
+ {
+ if (!askForName ||
+ KMessageBox::warningContinueCancel(m_mainWindow, i18n("<qt>A project view named <b>%1</b> already exists.<br>Do you want to overwrite it?</qt>")
+ .arg(currentProjectView), QString::null, i18n("Overwrite")) == KMessageBox::Continue)
+ {
+ node.parentNode().removeChild(node);
+ break;
+ } else
+ {
+ return;
+ }
+ }
+ }
+
+ QDomElement el = dom.createElement("projectview");
+ el.setAttribute("name", currentProjectView);
+ QDomElement item;
+ KURL::List openURLs = ViewManager::ref()->openedFiles(true); // get open urls
+ KURL::List::Iterator it;
+ for ( it = openURLs.begin(); it != openURLs.end(); ++it )
+ {
+ KURL url = (*it);
+ if (m_projectFiles.contains(url))
+ {
+ item = dom.createElement("viewitem");
+ item.setAttribute("url", QuantaCommon::qUrl(QExtFileInfo::toRelative(url, baseURL)) );
+ el.appendChild(item);
+ }
+ }
+
+ KURL::List toolbarList;
+ parent->getUserToolbarFiles(&toolbarList);
+ for (uint i =0 ; i < toolbarList.count(); i++)
+ {
+ item = dom.createElement("viewtoolbar");
+ KURL url = toolbarList[i];
+ url = QExtFileInfo::toRelative(url, baseURL);
+ item.setAttribute("url", QuantaCommon::qUrl(url) );
+ el.appendChild(item);
+ }
+
+ dom.firstChild().firstChild().appendChild( el );
+ parent->setModified();
+ adjustViewActions();
+}
+
+
+void ProjectPrivate::slotSelectProjectType(const QString &title)
+{
+ if ( png->radioLocal->isChecked() ) stack->raiseWidget( 0 );
+ if ( png->radioWeb ->isChecked() ) stack->raiseWidget( 1 );
+ if ( title == m_wizTitle )
+ emit setLocalFiles( pnl->checkInsert->isChecked() );
+}
+
+
+bool ProjectPrivate::createEmptyDom()
+{
+ QString str;
+ QTextStream stream(&str, IO_WriteOnly);
+ stream.setEncoding(QTextStream::UnicodeUTF8);
+
+ stream << "<!DOCTYPE webproject ><webproject>" << endl;
+ stream << "\t<project name=\"" << projectName << "\">" << endl;
+ stream << "\t\t<upload />" << endl;
+ stream << "\t</project>" << endl;
+ stream << "</webproject>" << endl;
+
+ QString sessionStr;
+ QTextStream sessionStream(&sessionStr, IO_WriteOnly);
+ sessionStream.setEncoding(QTextStream::UnicodeUTF8);
+
+ sessionStream << "<!DOCTYPE webprojectsession ><webprojectsession>" << endl;
+ sessionStream << "\t<session>" << endl;
+ sessionStream << "\t</session>" << endl;
+ sessionStream << "</webprojectsession>" << endl;
+
+ KURL sessionURL = projectURL;
+ QString fileName = projectURL.fileName();
+ if (fileName.endsWith(".webprj"))
+ fileName.replace(".webprj", ".session");
+ else
+ fileName += ".session";
+ sessionURL.setFileName(fileName);
+
+ bool result = true;
+
+ if (!projectURL.isLocalFile())
+ {
+ tempFile = new KTempFile(tmpDir); // tempFile will get deleted in slotProjectClose()
+ tempFile->setAutoDelete(true);
+ tempFile->textStream()->setEncoding(QTextStream::UnicodeUTF8);
+ *(tempFile->textStream()) << str;
+ tempFile->close();
+ result = QExtFileInfo::createDir(baseURL, m_mainWindow);
+ if (result)
+ result = KIO::NetAccess::upload(tempFile->name(), projectURL, m_mainWindow);
+ if (result)
+ m_tmpProjectFile = tempFile->name();
+
+ sessionTempFile = new KTempFile(tmpDir); // sessionTempFile will get deleted in slotProjectClose()
+ sessionTempFile->setAutoDelete(true);
+ sessionTempFile->textStream()->setEncoding(QTextStream::UnicodeUTF8);
+ *(sessionTempFile->textStream()) << sessionStr;
+ sessionTempFile->close();
+ result = KIO::NetAccess::upload(sessionTempFile->name(), sessionURL, m_mainWindow);
+ if (result)
+ m_tmpSessionFile= sessionTempFile->name();
+ } else
+ {
+ QFile f(projectURL.path());
+ if (f.open( IO_WriteOnly ))
+ {
+ QTextStream fstream(&f);
+ fstream.setEncoding(QTextStream::UnicodeUTF8);
+ fstream << str;
+ m_tmpProjectFile = projectURL.path(); // we are local: the temp file and the projectURL are the same
+ } else
+ {
+ result = false;
+ }
+ f.close();
+ if (result)
+ {
+ f.setName(sessionURL.path());
+ if (f.open(IO_WriteOnly))
+ {
+ QTextStream fstream(&f);
+ fstream.setEncoding(QTextStream::UnicodeUTF8);
+ fstream << sessionStr;
+ m_tmpSessionFile = sessionURL.path(); // we are local: the temp file and the projectURL are the same
+ } else
+ {
+ result = false;
+ }
+ f.close();
+ }
+ }
+
+ if (!result)
+ {
+ parent->hideSplash();
+ KMessageBox::sorry(m_mainWindow, i18n("<qt>Cannot open file <b>%1</b> for writing.</qt>").arg(projectURL.prettyURL(0, KURL::StripFileProtocol)));
+ delete tempFile;
+ tempFile = 0L;
+ delete sessionTempFile;
+ sessionTempFile = 0L;
+ return false;
+ }
+
+ dom.setContent(str);
+ m_sessionDom.setContent(sessionStr);
+ m_projectFiles.clear();
+ return true;
+}
+
+
+QStringList ProjectPrivate::treeStatusFromXML()
+{
+ QStringList folderList;
+ QDomNodeList nl = m_sessionDom.elementsByTagName("treestatus");
+ if (nl.count() > 0) {
+ nl = nl.item(0).childNodes();
+ for ( unsigned int i = 0; i < nl.count(); i++ )
+ {
+ QString urlString = nl.item(i).toElement().attribute("url");
+ folderList.append( baseURL.url(1) + urlString);
+ }
+ }
+ return folderList;
+}
+
+
+void ProjectPrivate::getStatusFromTree()
+{
+ // remove old status
+ QDomNodeList nl = m_sessionDom.elementsByTagName("treestatus");
+ QDomElement el;
+ for ( unsigned int i = 0; i < nl.count(); i++ )
+ {
+ el = nl.item(i).toElement();
+ el.parentNode().removeChild( el );
+ i--;
+ }
+ QStringList folderList;
+ parent->getTreeStatus( &folderList );
+ // toplevel folder is always open in a project and QExtFileInfo::toRelative
+ // creates strange output -> we remove the toplevel folder
+ if (folderList.count() > 0)
+ folderList.remove(folderList.begin());
+ if (folderList.count() > 0) {
+ // create the root element
+ QDomElement root = m_sessionDom.createElement("treestatus");
+ m_sessionDom.firstChild().firstChild().appendChild(root);
+ for (QStringList::Iterator it = folderList.begin(); it != folderList.end(); ++it) {
+ el = m_sessionDom.createElement("openfolder");
+ el.setAttribute("url", QuantaCommon::qUrl( QExtFileInfo::toRelative(KURL(*it), baseURL) ) );
+ root.appendChild( el );
+ }
+ }
+}
+
+
+/** create new project */
+void ProjectPrivate::slotNewProject()
+{
+ QWizard *wiz = new QWizard(m_mainWindow, "new", true);
+ wiz->setCaption(i18n("New Project Wizard"));
+ wiz->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
+
+ png = new ProjectNewGeneral(0L);
+
+ stack = new QWidgetStack(0L);
+
+ pnl = new ProjectNewLocal(stack);
+ pnw = new ProjectNewWeb(stack);
+ pnf = new ProjectNewFinal(0L);
+
+ stack->addWidget( pnl, 0);
+ stack->addWidget( pnw, 1 );
+
+ wiz->addPage( png, i18n("<b>General Project Settings</b>"));
+ wiz->addPage( stack, m_wizTitle );
+ wiz->addPage( pnf, i18n("<b>More Project Settings</b>"));
+
+ wiz->setNextEnabled ( png, false );
+ wiz->setBackEnabled ( stack, true );
+ wiz->setNextEnabled ( stack, true );
+ wiz->setNextEnabled ( pnf, false );
+ wiz->setFinishEnabled( pnf, true );
+
+ connect( png, SIGNAL(enableNextButton(QWidget *,bool)),
+ wiz, SLOT(setNextEnabled(QWidget*,bool)));
+ connect( png, SIGNAL(setBaseURL(const KURL&)),
+ pnl, SLOT( setBaseURL(const KURL&)));
+ connect( png, SIGNAL(setBaseURL(const KURL&)),
+ pnw, SLOT( setBaseURL(const KURL&)));
+ connect( this,SIGNAL(setLocalFiles(bool)),
+ pnl, SLOT(slotSetFiles(bool)));
+
+ connect(wiz, SIGNAL(selected(const QString &)),
+ this, SLOT (slotSelectProjectType(const QString &)));
+ connect(wiz, SIGNAL(helpClicked()), SLOT(slotNewProjectHelpClicked()));
+
+ connect( pnw, SIGNAL(enableMessagesWidget()),
+ parent, SIGNAL(enableMessageWidget()));
+ connect( pnw, SIGNAL(messages(const QString&)),
+ parent, SLOT (slotGetMessages(const QString&)));
+ connect( pnw, SIGNAL(enableNextButton(QWidget *,bool)),
+ wiz, SLOT(setNextEnabled(QWidget*,bool)));
+ connect( pnw, SIGNAL(enableNextButton(QWidget *,bool)),
+ wiz, SLOT(setBackEnabled(QWidget*,bool)));
+
+ QStringList lst = DTDs::ref()->nickNameList(true);
+ pnf->dtdCombo->insertStringList(lst);
+ QString defaultDTDName = DTDs::ref()->getDTDNickNameFromName(qConfig.defaultDocType.lower());
+ int pos = lst.findIndex(defaultDTDName);
+ if (pos >= 0)
+ pnf->dtdCombo->setCurrentItem(pos);
+
+ QStringList availableEncodingNames(KGlobal::charsets()->availableEncodingNames());
+ pnf->encodingCombo->insertStringList( availableEncodingNames );
+ QStringList::ConstIterator iter;
+ int iIndex = -1;
+ for (iter = availableEncodingNames.begin(); iter != availableEncodingNames.end(); ++iter)
+ {
+ ++iIndex;
+ if ((*iter).lower() == qConfig.defaultEncoding.lower())
+ {
+ pnf->encodingCombo->setCurrentItem(iIndex);
+ break;
+ }
+ }
+
+ png->linePrjName->setFocus();
+ if (wiz->exec())
+ {
+ slotCloseProject();
+ slotAcceptCreateProject();
+ }
+ delete wiz;
+
+ adjustActions();
+ parent->newStatus();
+}
+
+/** close project and edited files */
+void ProjectPrivate::slotCloseProject()
+{
+ if (!parent->hasProject()) return;
+ connect(ViewManager::ref(), SIGNAL(filesClosed(bool)), this, SLOT(slotProceedWithCloseProject(bool)));
+ parent->closeFiles();
+}
+
+void ProjectPrivate::slotProceedWithCloseProject(bool success)
+{
+ disconnect(ViewManager::ref(), SIGNAL(filesClosed(bool)), this, SLOT(slotProceedWithCloseProject(bool)));
+ if (!success) return;
+ emit eventHappened("before_project_close", baseURL.url(), QString::null);
+ if (!uploadProjectFile())
+ {
+ if (KMessageBox::warningContinueCancel(m_mainWindow, i18n("Saving of project failed. Do you want to continue with closing (might cause data loss)?"), i18n("Project Saving Error"), KStdGuiItem::close()) == KMessageBox::Cancel)
+ return;
+ }
+ emit eventHappened("after_project_close", baseURL.url(), QString::null);
+ // empty dom tree
+ dom.clear();
+ m_sessionDom.clear();
+ m_events->clear();
+ config->setGroup("Projects");
+ config->writePathEntry("Last Project", QString::null);
+ init();
+ parent->newProjectLoaded(projectName, baseURL, templateURL);
+ parent->reloadTree( &(m_projectFiles), true, QStringList());
+ adjustActions();
+ m_projectRecent->setCurrentItem(-1);
+ parent->newStatus();
+ kapp->processEvents(QEventLoop::ExcludeUserInput | QEventLoop::ExcludeSocketNotifiers);
+}
+
+
+/** open project file */
+void ProjectPrivate::slotOpenProject()
+{
+ KURL url = KFileDialog::getOpenURL( QString::null,
+ "*.wpj *.webprj"+i18n("|Project Files\n*|All Files"), m_mainWindow,
+ i18n("Open Project"));
+
+ if( !url.isEmpty() )
+ {
+ loadProject ( url );
+ }
+}
+
+
+/* save project file */
+bool ProjectPrivate::saveProject()
+{
+ if ( !parent->hasProject() ) return false;
+ bool result = true;
+ // remove old opened files
+ QDomElement el;
+ QDomNodeList nl = dom.firstChild().firstChild().childNodes();
+
+ for ( unsigned int i = 0; i < nl.count(); i++ )
+ {
+ el = nl.item(i).toElement();
+ if ( el.nodeName() == "openfile" )
+ {
+ el.parentNode().removeChild( el );
+ i--;
+ }
+ }
+ getStatusFromTree();
+ QFile f(m_tmpProjectFile);
+ if (f.open(IO_WriteOnly))
+ {
+ QTextStream stream( &f );
+ stream.setEncoding(QTextStream::UnicodeUTF8);
+ dom.save(stream, 2);
+ f.close();
+ f.setName(m_tmpSessionFile);
+ if (f.open(IO_WriteOnly))
+ {
+ QTextStream stream(&f);
+ stream.setEncoding(QTextStream::UnicodeUTF8);
+ m_sessionDom.save(stream, 2);
+ f.close();
+ }
+ m_modified = false;
+ parent->statusMsg(i18n( "Wrote project file %1" ).arg(m_tmpProjectFile));
+ } else
+ {
+ parent->hideSplash();
+ KMessageBox::error(m_mainWindow, i18n("<qt>Cannot open the file <b>%1</b> for writing.</qt>").arg(m_tmpProjectFile));
+ result = false;
+ }
+ return result;
+}
+
+
+void ProjectPrivate::loadProjectFromTemp(const KURL &url, const QString &tempFile, const QString &sessionTempFile)
+{
+ m_createSessionDom = true;
+ m_tmpProjectFile = tempFile;
+ if (!sessionTempFile.isEmpty())
+ m_tmpSessionFile = sessionTempFile;
+ projectURL = url;
+ QFile f(tempFile);
+ if (f.open(IO_ReadOnly))
+ {
+ baseURL = url;
+ baseURL.setPath(url.directory(true, true));
+ if (baseURL.isLocalFile())
+ {
+ QDir dir(baseURL.path());
+ baseURL.setPath(dir.canonicalPath());
+ baseURL.adjustPath(-1);
+ }
+ dom.setContent(&f);
+ f.close();
+ if (!sessionTempFile.isEmpty())
+ {
+ f.setName(sessionTempFile);
+ if (f.open(IO_ReadOnly))
+ {
+ m_sessionDom.setContent(&f);
+ m_createSessionDom = false;
+ f.close();
+ }
+ }
+ loadProjectXML();
+ openCurrentView();
+#if KDE_IS_VERSION(3,4,89)
+ kdDebug(24000) << "Add recent project: " << url << " : projectName= " << projectName << endl;
+ m_projectRecent->addURL(url, projectName);
+#else
+ m_projectRecent->addURL( url );
+#endif
+ m_projectRecent->setCurrentItem(0);
+ // remember the project in config
+ writeConfig();
+ } else
+ {
+ parent->hideSplash();
+ KMessageBox::error(m_mainWindow, i18n("<qt>Cannot open the file <b>%1</b> for reading.</qt>").arg(tempFile));
+ }
+}
+
+/** load project from file: url */
+bool ProjectPrivate::loadProject(const KURL &url)
+{
+ if (projectURL == url)
+ return true;
+ if (!url.isValid())
+ {
+ parent->hideSplash();
+ KMessageBox::sorry(m_mainWindow, i18n("<qt>Malformed URL: <b>%1</b></qt>").arg(url.prettyURL()));
+ return false;
+ }
+ if ( projectAlreadyOpen(url.url()) )
+ {
+ parent->hideSplash();
+ if (KMessageBox::warningContinueCancel(m_mainWindow, i18n("<qt>The project<br><b>%1</b><br> seems to be used by another Quanta instance.<br>You may end up with data loss if you open the same project in two instances, modify and save them in both.<br><br>Do you want to proceed with open?</qt>").arg(url.prettyURL()), QString::null, KStdGuiItem::open()) == KMessageBox::Cancel)
+ return false;
+ }
+ QString projectTmpFile;
+ QString sessionTmpFile;
+
+ // test if url is writeable and download to local file
+ if (KIO::NetAccess::exists(url, false, m_mainWindow) &&
+ KIO::NetAccess::download(url, projectTmpFile, m_mainWindow))
+ {
+ if (parent->hasProject())
+ {
+ slotCloseProject();
+ }
+ KURL sessionURL = url;
+ QString fileName = url.fileName();
+ if (fileName.endsWith(".webprj"))
+ fileName.replace(".webprj", ".session");
+ else
+ fileName += ".session";
+ sessionURL.setFileName(fileName);
+ if (KIO::NetAccess::exists(sessionURL, false, m_mainWindow))
+ KIO::NetAccess::download(sessionURL, sessionTmpFile, m_mainWindow);
+ else
+ {
+ QString sessionStr;
+ QTextStream sessionStream(&sessionStr, IO_WriteOnly);
+ sessionStream.setEncoding(QTextStream::UnicodeUTF8);
+
+ sessionStream << "<!DOCTYPE webprojectsession ><webprojectsession>" << endl;
+ sessionStream << "\t<session>" << endl;
+ sessionStream << "\t</session>" << endl;
+ sessionStream << "</webprojectsession>" << endl;
+ if (!sessionURL.isLocalFile())
+ {
+ sessionTempFile = new KTempFile(tmpDir); // sessionTempFile will get deleted in slotProjectClose()
+ sessionTempFile->setAutoDelete(true);
+ sessionTempFile->textStream()->setEncoding(QTextStream::UnicodeUTF8);
+ *(sessionTempFile->textStream()) << sessionStr;
+ sessionTempFile->close();
+ m_tmpSessionFile = sessionTempFile->name();
+ } else
+ {
+ QFile f(sessionURL.path());
+ if (f.open(IO_WriteOnly))
+ {
+ QTextStream fstream(&f);
+ fstream.setEncoding(QTextStream::UnicodeUTF8);
+ fstream << sessionStr;
+ m_tmpSessionFile = sessionURL.path(); // we are local: the temp file and the projectURL are the same
+ }
+ f.close();
+ }
+ m_sessionDom.setContent(sessionStr);
+ }
+ loadProjectFromTemp(url, projectTmpFile, sessionTmpFile);
+ } else
+ {
+ parent->hideSplash();
+ KMessageBox::error(m_mainWindow, i18n("<qt>Cannot access the project file <b>%1</b>.</qt>").arg(url.prettyURL(0, KURL::StripFileProtocol)));
+ return false;
+ }
+ return true;
+}
+
+
+/** dialog for add files */
+void ProjectPrivate::slotAddFiles()
+{
+ KURL::List list = KFileDialog::getOpenURLs(
+ baseURL.url(), i18n("*"), m_mainWindow, i18n("Insert Files in Project"));
+
+ if ( !list.isEmpty() )
+ {
+ KURL firstURL = list.first();
+ firstURL = QExtFileInfo::toRelative( firstURL, baseURL );
+
+ if ( firstURL.path().startsWith("/") || firstURL.path().startsWith("."))
+ {
+ KURLRequesterDlg *urlRequesterDlg = new KURLRequesterDlg( baseURL.prettyURL(), m_mainWindow, "");
+ urlRequesterDlg->setCaption(i18n("Files: Copy to Project"));
+ urlRequesterDlg->urlRequester()->setMode( KFile::Directory | KFile::ExistingOnly);
+ urlRequesterDlg->exec();
+ KURL destination = urlRequesterDlg->selectedURL();
+ delete urlRequesterDlg;
+
+ if ( !destination.isEmpty())
+ {
+ CopyTo *dlg = new CopyTo( baseURL);
+ connect(dlg, SIGNAL(deleteDialog(CopyTo*)),
+ SLOT (slotDeleteCopytoDlg(CopyTo*)));
+ connect(dlg, SIGNAL(addFilesToProject(const KURL::List&)), parent,
+ SLOT (slotInsertFilesAfterCopying(const KURL::List&)));
+ list = dlg->copy( list, destination );
+ return;
+ }
+ else {
+ return;
+ }
+ }
+
+ insertFiles( list );
+ //Take care also of the selected dirs
+ KURL dirURL;
+ for (uint i = 0; i < list.count(); i++)
+ {
+ dirURL = list[i];
+ if (dirURL.path().endsWith("/"))
+ {
+ insertFiles( dirURL, "*" );
+ }
+ }
+
+ parent->reloadTree( &(m_projectFiles), false, QStringList());
+ }
+}
+
+
+void ProjectPrivate::slotDeleteCopytoDlg(CopyTo *dlg)
+{
+//The CopyTo dlg is deleted only here!!
+ delete dlg;
+}
+
+
+void ProjectPrivate::slotAddDirectory()
+{
+ KURL url = KURL();
+ url = KFileDialog::getExistingURL(baseURL.prettyURL(), m_mainWindow,
+ i18n("Insert Folder in Project"));
+ parent->slotAddDirectory(url);
+}
+
+
+void ProjectPrivate::slotDebuggerOptions()
+{
+ // Debuggers Combo
+ KTrader::OfferList offers = KTrader::self()->query("Quanta/Debugger");
+ KTrader::OfferList::ConstIterator iterDbg;
+ for(iterDbg = offers.begin(); iterDbg != offers.end(); ++iterDbg)
+ {
+ KService::Ptr service = *iterDbg;
+ if(m_debuggerClientEdit == service->name())
+ {
+ DebuggerClient *dbg = 0L;
+ int errCode = 0;
+//Workaround for dynamic_cast not working correctly on SUSE 10, gcc 4.0.2
+//The correct way should be a simple:
+// DebuggerClient *dbg = KParts::ComponentFactory::createInstanceFromService<DebuggerClient>(service, this, 0, QStringList(), &errCode);
+ QObject* obj = KParts::ComponentFactory::createInstanceFromService<QObject>(service, this, 0, QStringList(), &errCode);
+ if (obj && obj->inherits("DebuggerClient"))
+ dbg = static_cast<DebuggerClient *>(obj);
+ if (dbg)
+ {
+ QDomNode projectNode = m_sessionDom.firstChild().firstChild();
+ QDomNode nodeThisDbg;
+ QDomNode nodeDbg = projectNode.namedItem("debuggers");
+ if(nodeDbg.isNull())
+ {
+ nodeDbg = m_sessionDom.createElement("debuggers");
+ projectNode.appendChild(nodeDbg);
+ }
+
+ nodeThisDbg = nodeDbg.namedItem(service->name());
+ if(nodeThisDbg.isNull())
+ {
+ nodeThisDbg = m_sessionDom.createElement(service->name());
+ nodeDbg.appendChild(nodeThisDbg);
+ }
+ dbg->showConfig(nodeThisDbg);
+ delete dbg;
+ }
+ else
+ {
+ parent->hideSplash();
+ KMessageBox::error(NULL, i18n("<qt>Unable to load the debugger plugin, error code %1 was returned: <b>%2</b>.</qt>").arg(errCode).arg(KLibLoader::self()->lastErrorMessage()), i18n("Debugger Error"));
+ }
+ }
+ }
+}
+
+void ProjectPrivate::slotDebuggerChanged(const QString &debugger)
+{
+ m_debuggerClientEdit = debugger;
+}
+
+
+void ProjectPrivate::writeConfig()
+{
+ config->reparseConfiguration();
+ config->setGroup("Projects");
+ // remember the last project in config
+ KURL url = projectURL.url();
+ url.setPass("");
+ config->writePathEntry("Last Project", url.url());
+ // add project to list
+ if (!projectURL.isEmpty())
+ {
+ QStringList projectList = QuantaCommon::readPathListEntry(config, "OpenProjects");
+ if (projectList.contains( projectURL.url() ) == 0)
+ {
+ projectList.append( projectURL.url() );
+ config->writePathEntry("OpenProjects", projectList);
+ // add the temp file to list
+ projectList = QuantaCommon::readPathListEntry(config, "ProjectTempFiles");
+ projectList.append(KURL::fromPathOrURL(m_tmpProjectFile).url());
+ config->writePathEntry("ProjectTempFiles", projectList);
+ projectList = QuantaCommon::readPathListEntry(config, "ProjectSessionTempFiles");
+ projectList.append(KURL::fromPathOrURL(m_tmpSessionFile).url());
+ config->writePathEntry("ProjectSessionTempFiles", projectList);
+ }
+ }
+ // save recent projects
+ config->deleteGroup("RecentProjects");
+ m_projectRecent->saveEntries(config, "RecentProjects");
+ config->sync();
+}
+
+
+void ProjectPrivate::removeFromConfig(const QString & urlStr)
+{
+ config->reparseConfiguration();
+ config->setGroup("Projects");
+ QStringList projectList = QuantaCommon::readPathListEntry(config, "OpenProjects");
+ int i = projectList.findIndex( urlStr );
+ if ( i > -1)
+ {
+ projectList.remove(projectList.at(i));
+ config->writePathEntry("OpenProjects", projectList);
+ // remove the temp file from list
+ projectList = QuantaCommon::readPathListEntry(config, "ProjectTempFiles");
+ projectList.remove(projectList.at(i));
+ config->writePathEntry("ProjectTempFiles", projectList);
+ projectList = QuantaCommon::readPathListEntry(config, "ProjectSessionTempFiles");
+ if (projectList.count() > (uint)i)
+ {
+ projectList.remove(projectList.at(i));
+ config->writePathEntry("ProjectSessionTempFiles", projectList);
+ }
+ }
+ config->sync();
+}
+
+
+bool ProjectPrivate::projectAlreadyOpen(const QString & urlStr)
+{
+ config->reparseConfiguration();
+ config->setGroup("Projects");
+ QStringList projectList = QuantaCommon::readPathListEntry(config, "OpenProjects");
+ return (projectList.contains(urlStr) != 0);
+}
+
+
+/* uploads project file */
+bool ProjectPrivate::uploadProjectFile()
+{
+ if (m_tmpProjectFile.isNull() || !saveProject())
+ return false;
+ KURL sessionURL = projectURL;
+ QString fileName = projectURL.fileName();
+ if (fileName.endsWith(".webprj"))
+ fileName.replace(".webprj", ".session");
+ else
+ fileName += ".session";
+ sessionURL.setFileName(fileName);
+
+ // no need to upload a local file because it is the same as the tempFile
+ if (projectURL.isLocalFile())
+ {
+ removeFromConfig( projectURL.url() ); // remove the project from the list of open projects
+ // delete all temp files we used
+ delete tempFile;
+ tempFile = 0L;
+ delete sessionTempFile;
+ sessionTempFile = 0L;
+ m_tmpProjectFile = QString::null;
+ return true;
+ }
+ if (KIO::NetAccess::upload(m_tmpProjectFile, projectURL, m_mainWindow) && KIO::NetAccess::upload(m_tmpSessionFile, sessionURL, m_mainWindow))
+ {
+ removeFromConfig(projectURL.url()); // remove the project from the list of open projects
+ if (quantaApp)
+ parent->statusMsg(i18n( "Uploaded project file %1" ).arg( projectURL.prettyURL()));
+ // delete all temp files we used
+ // first the one from creating a new project
+ delete tempFile;
+ tempFile = 0L;
+ delete sessionTempFile;
+ sessionTempFile = 0L;
+ // second the one from downloading a project
+ KIO::NetAccess::removeTempFile(m_tmpProjectFile);
+ KIO::NetAccess::removeTempFile(m_tmpSessionFile);
+ // third if we recovered after crash
+ KIO::NetAccess::del(KURL().fromPathOrURL(m_tmpProjectFile), m_mainWindow);
+ KIO::NetAccess::del(KURL().fromPathOrURL(m_tmpSessionFile), m_mainWindow);
+ m_tmpProjectFile = "";
+ m_tmpSessionFile = "";
+ }
+ else
+ {
+ if (quantaApp)
+ {
+ parent->statusMsg(QString::null );
+ KMessageBox::error(m_mainWindow, KIO::NetAccess::lastErrorString());
+ }
+ return false;
+ }
+ return true;
+}
+
+void ProjectPrivate::slotNewProjectHelpClicked()
+{
+ kapp->invokeHelp("create-new-project-3-2", "quanta");
+}
+
+#include "projectprivate.moc"