editors/sc-ide/core/doc_manager.cpp

   1 /*
   2     SuperCollider Qt IDE
   3     Copyright (c) 2012 Jakob Leben & Tim Blechmann
   4     http://www.audiosynth.com
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  19 */
  20
  21 #include "doc_manager.hpp"
  22 #include "main.hpp"
  23 #include "settings/manager.hpp"
  24 #include "../../common/SC_TextUtils.hpp"
  25
  26 #include <QPlainTextDocumentLayout>
  27 #include <QDebug>
  28 #include <QDir>
  29 #include <QFile>
  30 #include <QMessageBox>
  31 #include <QTextBlock>
  32 #include <QApplication>
  33
  34 using namespace ScIDE;
  35
  36 Document::Document():
  37     mId( QUuid::createUuid().toString().toAscii() ),
  38     mDoc( new QTextDocument(this) ),
  39     mTitle( "Untitled" ),
  40     mIndentWidth(4)
  41 {
  42     mDoc->setDocumentLayout( new QPlainTextDocumentLayout(mDoc) );
  43
  44     new SyntaxHighlighter(mDoc);
  45
  46     connect( Main::instance(), SIGNAL(applySettingsRequest(Settings::Manager*)),
  47              this, SLOT(applySettings(Settings::Manager*)) );
  48
  49     applySettings( Main::settings() );
  50 }
  51
  52 void Document::applySettings( Settings::Manager *settings )
  53 {
  54     QFont font = settings->codeFont();
  55     int indentWidth = settings->value("IDE/editor/indentWidth").toInt();
  56
  57     setDefaultFont(font);
  58     setIndentWidth(indentWidth);
  59 }
  60
  61 void Document::deleteTrailingSpaces()
  62 {
  63     QTextCursor cursor (textDocument());
  64     cursor.beginEditBlock();
  65     cursor.movePosition(QTextCursor::EndOfBlock);
  66     QTextDocument * doc = textDocument();
  67
  68     while( !cursor.atEnd() ) {
  69         while( (cursor.block().length() > 1) && doc->characterAt(cursor.position() - 1).isSpace())
  70             cursor.deletePreviousChar();
  71
  72         cursor.movePosition(QTextCursor::NextBlock);
  73         cursor.movePosition(QTextCursor::EndOfBlock);
  74     }
  75     cursor.endEditBlock();
  76 }
  77
  78 void Document::setDefaultFont( const QFont & font )
  79 {
  80     mDoc->setDefaultFont( font );
  81     // update tab stop, since it depends on font:
  82     setIndentWidth( mIndentWidth );
  83     emit defaultFontChanged();
  84 }
  85
  86 void Document::resetDefaultFont()
  87 {
  88     Settings::Manager *settings = Main::settings();
  89     setDefaultFont( settings->codeFont() );
  90 }
  91
  92 void Document::setIndentWidth( int numSpaces )
  93 {
  94     mIndentWidth = numSpaces;
  95
  96     QFontMetricsF fontMetrics( mDoc->defaultFont() );
  97     qreal tabStop = fontMetrics.width(' ') * numSpaces;
  98
  99     QTextOption options = mDoc->defaultTextOption();
 100     options.setTabStop(tabStop);
 101     mDoc->setDefaultTextOption(options);
 102 }
 103
 104
 105 DocumentManager::DocumentManager( Main *main, Settings::Manager * settings ):
 106     QObject(main)
 107 {
 108     connect(&mFsWatcher, SIGNAL(fileChanged(QString)), this, SLOT(onFileChanged(QString)));
 109
 110     connect(main, SIGNAL(storeSettingsRequest(Settings::Manager*)),
 111             this, SLOT(storeSettings(Settings::Manager*)));
 112
 113     loadRecentDocuments( settings );
 114 }
 115
 116 Document * DocumentManager::createDocument()
 117 {
 118     Document *doc = new Document();
 119     mDocHash.insert( doc->id(), doc );
 120     return doc;
 121 }
 122
 123 void DocumentManager::create()
 124 {
 125     Document *doc = createDocument();
 126
 127     Q_EMIT( opened(doc, 0, 0) );
 128 }
 129
 130 Document *DocumentManager::open( const QString & path, int initialCursorPosition, int selectionLength, bool toRecent )
 131 {
 132     QFileInfo info(path);
 133     QString cpath = info.canonicalFilePath();
 134     info.setFile(cpath);
 135
 136     if (cpath.isEmpty()) {
 137         qWarning() << "DocumentManager: Can not open file: canonical path is empty.";
 138         return 0;
 139     }
 140
 141     // Check if file already opened
 142     for( DocIterator it = mDocHash.begin(); it != mDocHash.end(); ++it ) {
 143         Document *doc = it.value();
 144         if(doc->mFilePath == cpath) {
 145             Q_EMIT( showRequest(doc, initialCursorPosition) );
 146             if (toRecent) addToRecent(doc);
 147             return doc;
 148         }
 149     }
 150
 151     // Open the file
 152     QFile file(cpath);
 153     if(!file.open(QIODevice::ReadOnly)) {
 154         qWarning() << "DocumentManager: the file" << cpath << "could not be opened for reading.";
 155         return 0;
 156     }
 157     QByteArray bytes( file.readAll() );
 158     file.close();
 159
 160     // strip .rtf
 161     bool isRTF = false;
 162     QString filePath = cpath;
 163     if (info.suffix() == QString("rtf")) {
 164         isRTF = true;
 165
 166         filePath += QString(".scd");
 167         int result = rtf2txt(bytes.data());
 168         bytes = bytes.left(result);
 169         QMessageBox::warning(NULL, QString(tr("Opening RTF File")),
 170                              QString(tr("Warning: RTF file will be converted to plain-text scd file.")));
 171     }
 172
 173     Document *doc = createDocument();
 174     doc->mDoc->setPlainText( QString::fromUtf8( bytes.data(), bytes.size() ) );
 175     doc->mDoc->setModified(false);
 176     doc->mFilePath = filePath;
 177     doc->mTitle = info.fileName();
 178
 179     mDocHash.insert( doc->id(), doc );
 180
 181     if (!isRTF)
 182         mFsWatcher.addPath(cpath);
 183
 184     Q_EMIT( opened(doc, initialCursorPosition, selectionLength) );
 185
 186     if (toRecent) this->addToRecent(doc);
 187
 188     return doc;
 189 }
 190
 191 bool DocumentManager::reload( Document *doc )
 192 {
 193     Q_ASSERT(doc);
 194
 195     if (doc->mFilePath.isEmpty())
 196         return false;
 197
 198     QFile file(doc->mFilePath);
 199     if(!file.open(QIODevice::ReadOnly)) {
 200         qWarning() << "DocumentManager: the file" << doc->mFilePath << "could not be opened for reading.";
 201         return false;
 202     }
 203     QByteArray bytes( file.readAll() );
 204     file.close();
 205
 206     doc->mDoc->setPlainText( QString::fromUtf8( bytes.data(), bytes.size() ) );
 207     doc->mDoc->setModified(false);
 208
 209     if (!mFsWatcher.files().contains(doc->mFilePath))
 210         mFsWatcher.addPath(doc->mFilePath);
 211
 212     return true;
 213 }
 214
 215 void DocumentManager::close( Document *doc )
 216 {
 217     Q_ASSERT(doc);
 218
 219     if( mDocHash.remove(doc->id()) == 0 ) {
 220         qWarning("DocumentManager: trying to close an unmanaged document.");
 221         return;
 222     }
 223
 224     if (!doc->mFilePath.isEmpty())
 225         mFsWatcher.removePath(doc->mFilePath);
 226
 227     Q_EMIT( closed(doc) );
 228     delete doc;
 229 }
 230
 231 bool DocumentManager::save( Document *doc )
 232 {
 233     Q_ASSERT(doc);
 234
 235     return doSaveAs( doc, doc->mFilePath );
 236 }
 237
 238 bool DocumentManager::saveAs( Document *doc, const QString & path )
 239 {
 240     Q_ASSERT(doc);
 241
 242     if (path.isEmpty()) {
 243         qWarning() << "DocumentManager: the saving path is empty.";
 244         return false;
 245     }
 246
 247     bool ok = doSaveAs( doc, path );
 248     if (ok)
 249         addToRecent(doc);
 250     return ok;
 251 }
 252
 253 bool DocumentManager::doSaveAs( Document *doc, const QString & path )
 254 {
 255     Q_ASSERT(doc);
 256
 257     doc->deleteTrailingSpaces();
 258
 259     QFile file(path);
 260     if(!file.open(QIODevice::WriteOnly)) {
 261         qWarning() << "DocumentManager: the file" << path << "could not be opened for writing.";
 262         return false;
 263     }
 264
 265     QString str = doc->textDocument()->toPlainText();
 266     file.write(str.toUtf8());
 267     file.close();
 268
 269     QFileInfo info(path);
 270     QString cpath = info.canonicalFilePath();
 271
 272     doc->mFilePath = cpath;
 273     doc->mTitle = info.fileName();
 274     doc->mDoc->setModified(false);
 275     doc->mSaveTime = info.lastModified();
 276
 277     // Always try to start watching, because the file could have been removed:
 278     if (!mFsWatcher.files().contains(cpath))
 279         mFsWatcher.addPath(cpath);
 280
 281     Q_EMIT(saved(doc));
 282
 283     return true;
 284 }
 285
 286 void DocumentManager::onFileChanged( const QString & path )
 287 {
 288     DocIterator it;
 289     for( it = mDocHash.begin(); it != mDocHash.end(); ++it )
 290     {
 291         Document *doc = it.value();
 292         if (doc->mFilePath == path) {
 293             QFileInfo info(doc->mFilePath);
 294             if (doc->mSaveTime < info.lastModified()) {
 295                 doc->mDoc->setModified(true);
 296                 emit changedExternally(doc);
 297             }
 298         }
 299     }
 300 }
 301
 302 void DocumentManager::addToRecent( Document *doc )
 303 {
 304     const QString &path = doc->mFilePath;
 305     int i = mRecent.indexOf(path);
 306     if (i != -1)
 307         mRecent.move( i, 0 );
 308     else {
 309         mRecent.prepend(path);
 310         if (mRecent.count() > mMaxRecent)
 311             mRecent.removeLast();
 312     }
 313
 314     emit recentsChanged();
 315 }
 316
 317 void DocumentManager::clearRecents()
 318 {
 319     mRecent.clear();
 320     emit recentsChanged();
 321 }
 322
 323 void DocumentManager::loadRecentDocuments( Settings::Manager *settings )
 324 {
 325     QVariantList list = settings->value("IDE/recentDocuments").value<QVariantList>();
 326     mRecent.clear();
 327     foreach (const QVariant & var, list)
 328         mRecent << var.toString();
 329 }
 330
 331 void DocumentManager::storeSettings( Settings::Manager *settings )
 332 {
 333     QVariantList list;
 334     foreach (const QString & path, mRecent)
 335         list << QVariant(path);
 336
 337     settings->setValue("IDE/recentDocuments", QVariant::fromValue<QVariantList>(list));
 338 }