comparison framework/MainWindowBase.cpp @ 595:b23bebfdfaba

Untabify

 static int handle_x11_error(Display *dpy, XErrorEvent *err)
 {
     char errstr[256];
     XGetErrorText(dpy, err->error_code, errstr, 256);
     if (err->error_code != BadWindow) {
-	cerr << "Sonic Visualiser: X Error: "
-		  << errstr << " " << int(err->error_code)
-		  << "\nin major opcode:  "
-		  << int(err->request_code) << endl;
+        cerr << "Sonic Visualiser: X Error: "
+                  << errstr << " " << int(err->error_code)
+                  << "\nin major opcode:  "
+                  << int(err->request_code) << endl;
     }
     return 0;
 }
 #undef Window
 #endif

 #endif
 
     connect(this, SIGNAL(hideSplash()), this, SLOT(emitHideSplash()));
     
     connect(CommandHistory::getInstance(), SIGNAL(commandExecuted()),
-	    this, SLOT(documentModified()));
+            this, SLOT(documentModified()));
     connect(CommandHistory::getInstance(), SIGNAL(documentRestored()),
-	    this, SLOT(documentRestored()));
+            this, SLOT(documentRestored()));
     
     SVDEBUG << "MainWindowBase: Creating view manager" << endl;
 
     m_viewManager = new ViewManager();
     connect(m_viewManager, SIGNAL(selectionChanged()),
-	    this, SLOT(updateMenuStates()));
+            this, SLOT(updateMenuStates()));
     connect(m_viewManager, SIGNAL(inProgressSelectionChanged()),
-	    this, SLOT(inProgressSelectionChanged()));
+            this, SLOT(inProgressSelectionChanged()));
 
     SVDEBUG << "MainWindowBase: Calculating view font size" << endl;
 
     // set a sensible default font size for views -- cannot do this
     // in Preferences, which is in base and not supposed to use QtGui

     }
 #endif
 
     m_paneStack = new PaneStack(0, m_viewManager);
     connect(m_paneStack, SIGNAL(currentPaneChanged(Pane *)),
-	    this, SLOT(currentPaneChanged(Pane *)));
+            this, SLOT(currentPaneChanged(Pane *)));
     connect(m_paneStack, SIGNAL(currentLayerChanged(Pane *, Layer *)),
-	    this, SLOT(currentLayerChanged(Pane *, Layer *)));
+            this, SLOT(currentLayerChanged(Pane *, Layer *)));
     connect(m_paneStack, SIGNAL(rightButtonMenuRequested(Pane *, QPoint)),
             this, SLOT(rightButtonMenuRequested(Pane *, QPoint)));
     connect(m_paneStack, SIGNAL(contextHelpChanged(const QString &)),
             this, SLOT(contextHelpChanged(const QString &)));
     connect(m_paneStack, SIGNAL(paneAdded(Pane *)),

             this,           SLOT(audioOverloadPluginDisabled()));
     connect(m_playSource, SIGNAL(audioTimeStretchMultiChannelDisabled()),
             this,           SLOT(audioTimeStretchMultiChannelDisabled()));
 
     connect(m_viewManager, SIGNAL(monitoringLevelsChanged(float, float)),
-	    this, SLOT(monitoringLevelsChanged(float, float)));
+            this, SLOT(monitoringLevelsChanged(float, float)));
 
     connect(m_viewManager, SIGNAL(playbackFrameChanged(sv_frame_t)),
             this, SLOT(playbackFrameChanged(sv_frame_t)));
 
     connect(m_viewManager, SIGNAL(globalCentreFrameChanged(sv_frame_t)),

         (currentPane != 0);
     bool haveCurrentLayer =
         (haveCurrentPane &&
          (currentLayer != 0));
     bool haveMainModel =
-	(getMainModel() != 0);
+        (getMainModel() != 0);
     bool havePlayTarget =
-	(m_playTarget != 0 || m_audioIO != 0);
+        (m_playTarget != 0 || m_audioIO != 0);
     bool haveSelection = 
-	(m_viewManager &&
-	 !m_viewManager->getSelections().empty());
+        (m_viewManager &&
+         !m_viewManager->getSelections().empty());
     bool haveCurrentEditableLayer =
-	(haveCurrentLayer &&
-	 currentLayer->isLayerEditable());
+        (haveCurrentLayer &&
+         currentLayer->isLayerEditable());
     bool haveCurrentTimeInstantsLayer = 
-	(haveCurrentLayer &&
-	 dynamic_cast<TimeInstantLayer *>(currentLayer));
+        (haveCurrentLayer &&
+         dynamic_cast<TimeInstantLayer *>(currentLayer));
     bool haveCurrentDurationLayer = 
-	(haveCurrentLayer &&
-	 (dynamic_cast<NoteLayer *>(currentLayer) ||
-	  dynamic_cast<FlexiNoteLayer *>(currentLayer) ||
+        (haveCurrentLayer &&
+         (dynamic_cast<NoteLayer *>(currentLayer) ||
+          dynamic_cast<FlexiNoteLayer *>(currentLayer) ||
           dynamic_cast<RegionLayer *>(currentLayer)));
     bool haveCurrentColour3DPlot =
         (haveCurrentLayer &&
          dynamic_cast<Colour3DPlotLayer *>(currentLayer));
     bool haveClipboardContents =

 {
 //    SVDEBUG << "MainWindowBase::documentModified" << endl;
 
     if (!m_documentModified) {
         //!!! this in subclass implementation?
-	setWindowTitle(tr("%1 (modified)").arg(windowTitle()));
+        setWindowTitle(tr("%1 (modified)").arg(windowTitle()));
     }
 
     m_documentModified = true;
     updateMenuStates();
 }

 {
 //    SVDEBUG << "MainWindowBase::documentRestored" << endl;
 
     if (m_documentModified) {
         //!!! this in subclass implementation?
-	QString wt(windowTitle());
-	wt.replace(tr(" (modified)"), "");
-	setWindowTitle(wt);
+        QString wt(windowTitle());
+        wt.replace(tr(" (modified)"), "");
+        setWindowTitle(wt);
     }
 
     m_documentModified = false;
     updateMenuStates();
 }

 MainWindowBase::playLoopToggled()
 {
     QAction *action = dynamic_cast<QAction *>(sender());
     
     if (action) {
-	m_viewManager->setPlayLoopMode(action->isChecked());
+        m_viewManager->setPlayLoopMode(action->isChecked());
     } else {
-	m_viewManager->setPlayLoopMode(!m_viewManager->getPlayLoopMode());
+        m_viewManager->setPlayLoopMode(!m_viewManager->getPlayLoopMode());
     }
 }
 
 void
 MainWindowBase::playSelectionToggled()
 {
     QAction *action = dynamic_cast<QAction *>(sender());
     
     if (action) {
-	m_viewManager->setPlaySelectionMode(action->isChecked());
+        m_viewManager->setPlaySelectionMode(action->isChecked());
     } else {
-	m_viewManager->setPlaySelectionMode(!m_viewManager->getPlaySelectionMode());
+        m_viewManager->setPlaySelectionMode(!m_viewManager->getPlaySelectionMode());
     }
 }
 
 void
 MainWindowBase::playSoloToggled()
 {
     QAction *action = dynamic_cast<QAction *>(sender());
     
     if (action) {
-	m_viewManager->setPlaySoloMode(action->isChecked());
+        m_viewManager->setPlaySoloMode(action->isChecked());
     } else {
-	m_viewManager->setPlaySoloMode(!m_viewManager->getPlaySoloMode());
+        m_viewManager->setPlaySoloMode(!m_viewManager->getPlaySoloMode());
     }
 
     if (m_viewManager->getPlaySoloMode()) {
         currentPaneChanged(m_paneStack->getCurrentPane());
     } else {

 void
 MainWindowBase::selectAll()
 {
     if (!getMainModel()) return;
     m_viewManager->setSelection(Selection(getMainModel()->getStartFrame(),
-					  getMainModel()->getEndFrame()));
+                                          getMainModel()->getEndFrame()));
 }
 
 void
 MainWindowBase::selectToStart()
 {
     if (!getMainModel()) return;
     m_viewManager->setSelection(Selection(getMainModel()->getStartFrame(),
-					  m_viewManager->getGlobalCentreFrame()));
+                                          m_viewManager->getGlobalCentreFrame()));
 }
 
 void
 MainWindowBase::selectToEnd()
 {
     if (!getMainModel()) return;
     m_viewManager->setSelection(Selection(m_viewManager->getGlobalCentreFrame(),
-					  getMainModel()->getEndFrame()));
+                                          getMainModel()->getEndFrame()));
 }
 
 void
 MainWindowBase::selectVisible()
 {

 
 void
 MainWindowBase::deleteSelected()
 {
     if (m_paneStack->getCurrentPane() &&
-	m_paneStack->getCurrentPane()->getSelectedLayer()) {
+        m_paneStack->getCurrentPane()->getSelectedLayer()) {
         
         Layer *layer = m_paneStack->getCurrentPane()->getSelectedLayer();
 
         if (m_viewManager) {
 

                 for (MultiSelection::SelectionList::iterator i = selections.begin();
                      i != selections.end(); ++i) {
                     layer->deleteSelection(*i);
                 }
             }
-	}
+        }
     }
 }
 
 // FrameTimer method
 

     }
 
     ReadOnlyWaveFileModel *newModel = new ReadOnlyWaveFileModel(source, rate);
 
     if (!newModel->isOK()) {
-	delete newModel;
+        delete newModel;
         m_openingAudioFile = false;
         if (source.wasCancelled()) {
             return FileOpenCancelled;
         } else { 
             return FileOpenFailed;

         }
         PlayParameterRepository::getInstance()->addPlayable(newModel);
 
         SVDEBUG << "SV about to call setMainModel(" << newModel << "): prevMain is " << prevMain << endl;
 
-	m_document->setMainModel(newModel);
-
-	setupMenus();
-
-	if (loadedTemplate || (m_sessionFile == "")) {
+        m_document->setMainModel(newModel);
+
+        setupMenus();
+
+        if (loadedTemplate || (m_sessionFile == "")) {
             //!!! shouldn't be dealing directly with title from here -- call a method
-	    setWindowTitle(tr("%1: %2")
+            setWindowTitle(tr("%1: %2")
                            .arg(QApplication::applicationName())
                            .arg(source.getLocation()));
-	    CommandHistory::getInstance()->clear();
-	    CommandHistory::getInstance()->documentSaved();
-	    m_documentModified = false;
-	} else {
-	    setWindowTitle(tr("%1: %2 [%3]")
+            CommandHistory::getInstance()->clear();
+            CommandHistory::getInstance()->documentSaved();
+            m_documentModified = false;
+        } else {
+            setWindowTitle(tr("%1: %2 [%3]")
                            .arg(QApplication::applicationName())
-			   .arg(QFileInfo(m_sessionFile).fileName())
-			   .arg(source.getLocation()));
-	    if (m_documentModified) {
-		m_documentModified = false;
-		documentModified(); // so as to restore "(modified)" window title
-	    }
-	}
+                           .arg(QFileInfo(m_sessionFile).fileName())
+                           .arg(source.getLocation()));
+            if (m_documentModified) {
+                m_documentModified = false;
+                documentModified(); // so as to restore "(modified)" window title
+            }
+        }
 
         if (!source.isRemote()) m_audioFile = source.getLocalFilename();
 
     } else if (mode == CreateAdditionalModel) {
 
         SVCERR << "Mode is CreateAdditionalModel" << endl;
         
-	CommandHistory::getInstance()->startCompoundOperation
-	    (tr("Import \"%1\"").arg(source.getBasename()), true);
-
-	m_document->addImportedModel(newModel);
-
-	AddPaneCommand *command = new AddPaneCommand(this);
-	CommandHistory::getInstance()->addCommand(command);
-
-	Pane *pane = command->getPane();
+        CommandHistory::getInstance()->startCompoundOperation
+            (tr("Import \"%1\"").arg(source.getBasename()), true);
+
+        m_document->addImportedModel(newModel);
+
+        AddPaneCommand *command = new AddPaneCommand(this);
+        CommandHistory::getInstance()->addCommand(command);
+
+        Pane *pane = command->getPane();
 
         if (m_timeRulerLayer) {
             SVCERR << "Have time ruler, adding it" << endl;
             m_document->addLayerToView(pane, m_timeRulerLayer);
         } else {
             SVCERR << "Do not have time ruler" << endl;
         }
 
-	Layer *newLayer = m_document->createImportedLayer(newModel);
-
-	if (newLayer) {
-	    m_document->addLayerToView(pane, newLayer);
-	}
-	
-	CommandHistory::getInstance()->endCompoundOperation();
+        Layer *newLayer = m_document->createImportedLayer(newModel);
+
+        if (newLayer) {
+            m_document->addLayerToView(pane, newLayer);
+        }
+        
+        CommandHistory::getInstance()->endCompoundOperation();
 
     } else if (mode == ReplaceCurrentPane) {
 
         // We know there is a current pane, otherwise we would have
         // reset the mode to CreateAdditionalModel above; and we know

                 replace = layer;
                 break;
             }
         }
 
-	CommandHistory::getInstance()->startCompoundOperation
-	    (tr("Import \"%1\"").arg(source.getBasename()), true);
-
-	m_document->addImportedModel(newModel);
+        CommandHistory::getInstance()->startCompoundOperation
+            (tr("Import \"%1\"").arg(source.getBasename()), true);
+
+        m_document->addImportedModel(newModel);
 
         if (replace) {
             m_document->removeLayerFromView(pane, replace);
         }
 
-	Layer *newLayer = m_document->createImportedLayer(newModel);
-
-	if (newLayer) {
-	    m_document->addLayerToView(pane, newLayer);
-	}
-	
-	CommandHistory::getInstance()->endCompoundOperation();
+        Layer *newLayer = m_document->createImportedLayer(newModel);
+
+        if (newLayer) {
+            m_document->addLayerToView(pane, newLayer);
+        }
+        
+        CommandHistory::getInstance()->endCompoundOperation();
     }
 
     updateMenuStates();
     m_recentFiles.addFile(source.getLocation());
     if (!source.isRemote()) {

     SVDEBUG << "MainWindowBase::openLayer(" << source.getLocation() << ")" << endl;
 
     Pane *pane = m_paneStack->getCurrentPane();
     
     if (!pane) {
-	// shouldn't happen, as the menu action should have been disabled
-	cerr << "WARNING: MainWindowBase::openLayer: no current pane" << endl;
-	return FileOpenWrongMode;
+        // shouldn't happen, as the menu action should have been disabled
+        cerr << "WARNING: MainWindowBase::openLayer: no current pane" << endl;
+        return FileOpenWrongMode;
     }
 
     if (!getMainModel()) {
-	// shouldn't happen, as the menu action should have been disabled
-	cerr << "WARNING: MainWindowBase::openLayer: No main model -- hence no default sample rate available" << endl;
-	return FileOpenWrongMode;
+        // shouldn't happen, as the menu action should have been disabled
+        cerr << "WARNING: MainWindowBase::openLayer: No main model -- hence no default sample rate available" << endl;
+        return FileOpenWrongMode;
     }
 
     if (!source.isAvailable()) return FileOpenFailed;
     source.waitForData();
 

     SVDEBUG << "MainWindowBase::openImage(" << source.getLocation() << ")" << endl;
 
     Pane *pane = m_paneStack->getCurrentPane();
     
     if (!pane) {
-	// shouldn't happen, as the menu action should have been disabled
-	cerr << "WARNING: MainWindowBase::openImage: no current pane" << endl;
-	return FileOpenWrongMode;
+        // shouldn't happen, as the menu action should have been disabled
+        cerr << "WARNING: MainWindowBase::openImage: no current pane" << endl;
+        return FileOpenWrongMode;
     }
 
     if (!m_document->getMainModel()) {
         return FileOpenWrongMode;
     }

 
     if (ok) {
 
         emit activity(tr("Import session file \"%1\"").arg(source.getLocation()));
 
-	setWindowTitle(tr("%1: %2")
+        setWindowTitle(tr("%1: %2")
                        .arg(QApplication::applicationName())
-		       .arg(source.getLocation()));
-
-	if (!source.isRemote()) m_sessionFile = source.getLocalFilename();
-
-	setupMenus();
+                       .arg(source.getLocation()));
+
+        if (!source.isRemote()) m_sessionFile = source.getLocalFilename();
+
+        setupMenus();
         findTimeRulerLayer();
 
-	CommandHistory::getInstance()->clear();
-	CommandHistory::getInstance()->documentSaved();
-	m_documentModified = false;
-	updateMenuStates();
+        CommandHistory::getInstance()->clear();
+        CommandHistory::getInstance()->documentSaved();
+        m_documentModified = false;
+        updateMenuStates();
 
         m_recentFiles.addFile(source.getLocation());
 
         if (!source.isRemote()) {
             // for file dialog

         }
 
         emit sessionLoaded();
 
     } else {
-	setWindowTitle(QApplication::applicationName());
+        setWindowTitle(QApplication::applicationName());
     }
 
     return ok ? FileOpenSucceeded : FileOpenFailed;
 }
 

 
     if (ok) {
 
         emit activity(tr("Open session template \"%1\"").arg(source.getLocation()));
 
-	setupMenus();
+        setupMenus();
         findTimeRulerLayer();
 
-	CommandHistory::getInstance()->clear();
-	CommandHistory::getInstance()->documentSaved();
-	m_documentModified = false;
-	updateMenuStates();
+        CommandHistory::getInstance()->clear();
+        CommandHistory::getInstance()->documentSaved();
+        m_documentModified = false;
+        updateMenuStates();
 
         emit sessionLoaded();
     }
 
     return ok ? FileOpenSucceeded : FileOpenFailed;

 MainWindowBase::createDocument()
 {
     m_document = new Document;
 
     connect(m_document, SIGNAL(layerAdded(Layer *)),
-	    this, SLOT(layerAdded(Layer *)));
+            this, SLOT(layerAdded(Layer *)));
     connect(m_document, SIGNAL(layerRemoved(Layer *)),
-	    this, SLOT(layerRemoved(Layer *)));
+            this, SLOT(layerRemoved(Layer *)));
     connect(m_document, SIGNAL(layerAboutToBeDeleted(Layer *)),
-	    this, SLOT(layerAboutToBeDeleted(Layer *)));
+            this, SLOT(layerAboutToBeDeleted(Layer *)));
     connect(m_document, SIGNAL(layerInAView(Layer *, bool)),
-	    this, SLOT(layerInAView(Layer *, bool)));
+            this, SLOT(layerInAView(Layer *, bool)));
 
     connect(m_document, SIGNAL(modelAdded(Model *)),
-	    this, SLOT(modelAdded(Model *)));
+            this, SLOT(modelAdded(Model *)));
     connect(m_document, SIGNAL(mainModelChanged(WaveFileModel *)),
-	    this, SLOT(mainModelChanged(WaveFileModel *)));
+            this, SLOT(mainModelChanged(WaveFileModel *)));
     connect(m_document, SIGNAL(modelAboutToBeDeleted(Model *)),
-	    this, SLOT(modelAboutToBeDeleted(Model *)));
+            this, SLOT(modelAboutToBeDeleted(Model *)));
 
     connect(m_document, SIGNAL(modelGenerationFailed(QString, QString)),
             this, SLOT(modelGenerationFailed(QString, QString)));
     connect(m_document, SIGNAL(modelRegenerationWarning(QString, QString, QString)),
             this, SLOT(modelRegenerationWarning(QString, QString, QString)));

     }
 
     out << "<display>\n";
 
     out << QString("  <window width=\"%1\" height=\"%2\"/>\n")
-	.arg(width()).arg(height());
+        .arg(width()).arg(height());
 
     for (int i = 0; i < m_paneStack->getPaneCount(); ++i) {
 
-	Pane *pane = m_paneStack->getPane(i);
-
-	if (pane) {
+        Pane *pane = m_paneStack->getPane(i);
+
+        if (pane) {
             pane->toXml(out, indent);
-	}
+        }
     }
 
     out << "</display>\n";
 
     m_viewManager->getSelection().toXml(out);

         if (action) action->setChecked(false);
     } else {
         if (m_audioIO) m_audioIO->resume();
         else if (m_playTarget) m_playTarget->resume();
         playbackFrameChanged(m_viewManager->getPlaybackFrame());
-	m_playSource->play(m_viewManager->getPlaybackFrame());
+        m_playSource->play(m_viewManager->getPlaybackFrame());
     }
 }
 
 void
 MainWindowBase::record()

         
         m_document->setMainModel(model);
         setupMenus();
         findTimeRulerLayer();
 
-	if (loadedTemplate || (m_sessionFile == "")) {
+        if (loadedTemplate || (m_sessionFile == "")) {
             //!!! shouldn't be dealing directly with title from here -- call a method
-	    setWindowTitle(tr("%1: %2")
+            setWindowTitle(tr("%1: %2")
                            .arg(QApplication::applicationName())
                            .arg(model->getLocation()));
-	    CommandHistory::getInstance()->clear();
-	    CommandHistory::getInstance()->documentSaved();
-	    m_documentModified = false;
-	} else {
-	    setWindowTitle(tr("%1: %2 [%3]")
+            CommandHistory::getInstance()->clear();
+            CommandHistory::getInstance()->documentSaved();
+            m_documentModified = false;
+        } else {
+            setWindowTitle(tr("%1: %2 [%3]")
                            .arg(QApplication::applicationName())
-			   .arg(QFileInfo(m_sessionFile).fileName())
-			   .arg(model->getLocation()));
-	    if (m_documentModified) {
-		m_documentModified = false;
-		documentModified(); // so as to restore "(modified)" window title
-	    }
-	}
+                           .arg(QFileInfo(m_sessionFile).fileName())
+                           .arg(model->getLocation()));
+            if (m_documentModified) {
+                m_documentModified = false;
+                documentModified(); // so as to restore "(modified)" window title
+            }
+        }
 
     } else {
 
         CommandHistory::getInstance()->startCompoundOperation
             (tr("Import Recorded Audio"), true);

         Layer *newLayer = m_document->createImportedLayer(model);
 
         if (newLayer) {
             m_document->addLayerToView(pane, newLayer);
         }
-	
+        
         CommandHistory::getInstance()->endCompoundOperation();
     }
 
     updateMenuStates();
     m_recentFiles.addFile(model->getLocation());

 }
 
 MainWindowBase::AddPaneCommand::~AddPaneCommand()
 {
     if (m_pane && !m_added) {
-	m_mw->m_paneStack->deletePane(m_pane);
+        m_mw->m_paneStack->deletePane(m_pane);
     }
 }
 
 QString
 MainWindowBase::AddPaneCommand::getName() const

 
 void
 MainWindowBase::AddPaneCommand::execute()
 {
     if (!m_pane) {
-	m_prevCurrentPane = m_mw->m_paneStack->getCurrentPane();
-	m_pane = m_mw->m_paneStack->addPane();
+        m_prevCurrentPane = m_mw->m_paneStack->getCurrentPane();
+        m_pane = m_mw->m_paneStack->addPane();
 
         connect(m_pane, SIGNAL(contextHelpChanged(const QString &)),
                 m_mw, SLOT(contextHelpChanged(const QString &)));
     } else {
-	m_mw->m_paneStack->showPane(m_pane);
+        m_mw->m_paneStack->showPane(m_pane);
     }
 
     m_mw->m_paneStack->setCurrentPane(m_pane);
     m_added = true;
 }

 }
 
 MainWindowBase::RemovePaneCommand::~RemovePaneCommand()
 {
     if (m_pane && !m_added) {
-	m_mw->m_paneStack->deletePane(m_pane);
+        m_mw->m_paneStack->deletePane(m_pane);
     }
 }
 
 QString
 MainWindowBase::RemovePaneCommand::getName() const

 
 void
 MainWindowBase::deleteCurrentPane()
 {
     CommandHistory::getInstance()->startCompoundOperation
-	(tr("Delete Pane"), true);
+        (tr("Delete Pane"), true);
 
     Pane *pane = m_paneStack->getCurrentPane();
     if (pane) {
-	while (pane->getLayerCount() > 0) {
-	    Layer *layer = pane->getLayer(0);
-	    if (layer) {
-		m_document->removeLayerFromView(pane, layer);
-	    } else {
-		break;
-	    }
-	}
-
-	RemovePaneCommand *command = new RemovePaneCommand(this, pane);
-	CommandHistory::getInstance()->addCommand(command);
+        while (pane->getLayerCount() > 0) {
+            Layer *layer = pane->getLayer(0);
+            if (layer) {
+                m_document->removeLayerFromView(pane, layer);
+            } else {
+                break;
+            }
+        }
+
+        RemovePaneCommand *command = new RemovePaneCommand(this, pane);
+        CommandHistory::getInstance()->addCommand(command);
     }
 
     CommandHistory::getInstance()->endCompoundOperation();
 
     updateMenuStates();

 void
 MainWindowBase::deleteCurrentLayer()
 {
     Pane *pane = m_paneStack->getCurrentPane();
     if (pane) {
-	Layer *layer = pane->getSelectedLayer();
-	if (layer) {
-	    m_document->removeLayerFromView(pane, layer);
-	}
+        Layer *layer = pane->getSelectedLayer();
+        if (layer) {
+            m_document->removeLayerFromView(pane, layer);
+        }
     }
     updateMenuStates();
 }
 
 void

 //    SVDEBUG << "MainWindowBase::layerAboutToBeDeleted(" << layer << ")" << endl;
 
     removeLayerEditDialog(layer);
 
     if (m_timeRulerLayer && (layer == m_timeRulerLayer)) {
-//	cerr << "(this is the time ruler layer)" << endl;
-	m_timeRulerLayer = 0;
+//        cerr << "(this is the time ruler layer)" << endl;
+        m_timeRulerLayer = 0;
     }
 }
 
 void
 MainWindowBase::layerInAView(Layer *layer, bool inAView)

 
 void
 MainWindowBase::modelAdded(Model *model)
 {
 //    SVDEBUG << "MainWindowBase::modelAdded(" << model << ")" << endl;
-	std::cerr << "\nAdding model " << model->getTypeName() << " to playsource " << std::endl;
+        std::cerr << "\nAdding model " << model->getTypeName() << " to playsource " << std::endl;
     m_playSource->addModel(model);
 }
 
 void
 MainWindowBase::mainModelChanged(WaveFileModel *model)

                   << pane << endl;
         return;
     }
 
     CommandHistory::getInstance()->startCompoundOperation
-	(tr("Delete Pane"), true);
+        (tr("Delete Pane"), true);
 
     while (pane->getLayerCount() > 0) {
         Layer *layer = pane->getLayer(0);
         if (layer) {
             m_document->removeLayerFromView(pane, layer);