more stuff

src/plugins/coreplugin/editormanager/editormanager.cpp

@@ -139,6 +139,7 @@ struct EditorManagerPrivate {
     Internal::EditorView *m_view;
     Internal::SplitterOrView *m_splitter;
     QPointer<IEditor> m_currentEditor;
+    QPointer<SplitterOrView> m_currentView;
     QStackedLayout *m_stackedLayout;
 
     ICore *m_core;
@@ -382,8 +383,10 @@ EditorManager::EditorManager(ICore *core, QWidget *parent) :
 
 
     // other setup
-    m_d->m_view = new EditorView(m_d->m_editorModel, this);
-    m_d->m_splitter = new SplitterOrView(m_d->m_view);
+    m_d->m_splitter = new SplitterOrView(m_d->m_editorModel);
+    m_d->m_splitter->setRoot(true);
+    m_d->m_view = m_d->m_splitter->view();
+
 
     m_d->m_stackedLayout = new QStackedLayout(this);
     m_d->m_stackedLayout->addWidget(m_d->m_splitter);
@@ -474,6 +477,7 @@ void EditorManager::handleContextChange(IContext *context)
 
 void EditorManager::setCurrentEditor(IEditor *editor, bool ignoreNavigationHistory)
 {
+    setCurrentView(0);
     if (m_d->m_currentEditor == editor)
         return;
 
@@ -491,6 +495,26 @@ void EditorManager::setCurrentEditor(IEditor *editor, bool ignoreNavigationHisto
     emit currentEditorChanged(editor);
 }
 
+
+void EditorManager::setCurrentView(Core::Internal::SplitterOrView *view)
+{
+    if (view == m_d->m_currentView)
+        return;
+
+    SplitterOrView *old = m_d->m_currentView;
+    m_d->m_currentView = view;
+
+    if (old)
+        old->update();
+    if (view)
+        view->update();
+}
+
+Core::Internal::SplitterOrView *EditorManager::currentView() const
+{
+    return m_d->m_currentView;
+}
+
 QList<IEditor *> EditorManager::editorsForFileName(const QString &filename) const
 {
     QList<IEditor *> found;
@@ -516,16 +540,19 @@ void EditorManager::closeEditor()
     closeEditor(m_d->m_currentEditor);
 }
 
-void EditorManager::closeView(Core::Internal::EditorView *view)
+void EditorManager::emptyView(Core::Internal::EditorView *view)
 {
     if (!view)
         return;
 
-    if (view == m_d->m_view) {
-        closeEditors(QList<IEditor *>() << view->currentEditor());
-    } else {
+
     QList<IEditor *> editors = view->editors();
     foreach (IEditor *editor, editors) {
+        if (!m_d->m_editorModel->isDuplicate(editor)) {
+            editors.removeAll(editor);
+            view->removeEditor(editor);
+            continue;
+        }
         emit editorAboutToClose(editor);
         removeEditor(editor);
         view->removeEditor(editor);
@@ -535,6 +562,34 @@ void EditorManager::closeView(Core::Internal::EditorView *view)
         delete editor;
     }
 }
+
+void EditorManager::closeView(Core::Internal::EditorView *view)
+{
+    if (!view)
+        return;
+
+    if (view == m_d->m_view) {
+        closeEditors(QList<IEditor *>() << view->currentEditor());
+        return;
+    }
+
+    emptyView(view);
+
+    SplitterOrView *splitterOrView = m_d->m_splitter->findView(view);
+    Q_ASSERT(splitterOrView->view() == view);
+    SplitterOrView *splitter = m_d->m_splitter->findSplitter(splitterOrView);
+    Q_ASSERT(splitterOrView->hasEditors() == false);
+    delete splitterOrView;
+
+    splitter->unsplit();
+
+    SplitterOrView *newCurrent = splitter->findFirstView();
+    if (newCurrent) {
+        if (newCurrent->editor())
+            activateEditor(newCurrent->view(), newCurrent->editor());
+        else
+            setCurrentView(newCurrent);
+    }
 }
 
 void EditorManager::closeEditor(Core::IEditor *editor)
@@ -574,7 +629,6 @@ QList<IFile *> EditorManager::filesForEditors(QList<IEditor *> editors) const
 
 bool EditorManager::closeAllEditors(bool askAboutModifiedEditors)
 {
-    unsplitAll();
     return closeEditors(openedEditors(), askAboutModifiedEditors);
 }
 
@@ -623,16 +677,11 @@ bool EditorManager::closeEditors(const QList<IEditor*> editorsToClose, bool askA
     foreach(IEditor *editor, acceptedEditors)
         acceptedEditors += m_d->m_editorModel->duplicatesFor(editor);
 
-    bool currentEditorRemoved = false;
-    IEditor *current = currentEditor();
-    if (current)
+    QList<EditorView*> currentViews;
+    EditorView *currentView = 0;
+    if (currentEditor())
         addCurrentPositionToNavigationHistory(true);
-    // remove current editor last, for optimization
-    if (acceptedEditors.contains(current)) {
-        currentEditorRemoved = true;
-        acceptedEditors.removeAll(current);
-        acceptedEditors.append(current);
-    }
+
     // remove the editors
     foreach (IEditor *editor, acceptedEditors) {
         emit editorAboutToClose(editor);
@@ -643,80 +692,128 @@ bool EditorManager::closeEditors(const QList<IEditor*> editorsToClose, bool askA
         }
 
         removeEditor(editor);
-        if (SplitterOrView *view = m_d->m_splitter->findView(editor))
+        if (SplitterOrView *view = m_d->m_splitter->findView(editor)) {
+            if (editor == view->view()->currentEditor()) {
+                currentViews += view->view();
+                if (editor == m_d->m_currentEditor)
+                    currentView = view->view();
+            }
             view->view()->removeEditor(editor);
         }
+    }
+
+    foreach (EditorView *view, currentViews) {
+        IEditor *newCurrent = view->currentEditor();
+        if (!newCurrent)
+            newCurrent = pickUnusedEditor();
+        if (!newCurrent) {
+            // pick the first one that can be duplicated
+            foreach (IEditor *e, m_d->m_editorHistory) {
+                if (e->duplicateSupported()) {
+                    newCurrent = e;
+                    break;
+                }
+            }
+        }
+
+        if (newCurrent)
+            activateEditor(view, newCurrent, NoActivate);
+    }
+
+
     emit editorsClosed(acceptedEditors);
     foreach (IEditor *editor, acceptedEditors) {
         delete editor;
     }
-    if (currentEditorRemoved) {
-        setCurrentEditor(0, true);
-    }
+
+    if (currentView)
+        activateEditor(currentView, currentView->currentEditor());
+
     return !closingFailed;
 }
 
+IEditor *EditorManager::pickUnusedEditor() const
+{
+    foreach (IEditor *editor, m_d->m_editorHistory) {
+        SplitterOrView *view = m_d->m_splitter->findView(editor);
+        if (!view || view->editor() != editor)
+            return editor;
+    }
+    return 0;
+}
 
 void EditorManager::activateEditor(IEditor *editor, OpenEditorFlags flags)
 {
-    SplitterOrView *splitterOrView = m_d->m_currentEditor ?
-                                     m_d->m_splitter->findView(m_d->m_currentEditor)
-                                     : m_d->m_splitter->findFirstView();
+
+    SplitterOrView *splitterOrView = m_d->m_currentView;
+    setCurrentView(0);
+
+    qDebug() << "currentView" << splitterOrView;
+    if (!splitterOrView)
+        splitterOrView = m_d->m_splitter->findEmptyView();
+    qDebug() << "empty" << splitterOrView;
+
+
+    if (!splitterOrView && m_d->m_currentEditor)
+        splitterOrView = m_d->m_splitter->findView(m_d->m_currentEditor);
+    qDebug() << "current editor" << splitterOrView;
+
+    if (!splitterOrView)
+        splitterOrView = m_d->m_splitter->findFirstView();
+    qDebug() << "first" << splitterOrView;
+    if (!splitterOrView) {
+        splitterOrView = m_d->m_splitter;
+    }
+    qDebug() << "origin" << splitterOrView;
+
     activateEditor(splitterOrView->view(), editor, flags);
 }
 
-
-void EditorManager::activateEditor(Core::Internal::EditorView *view, Core::IEditor *editor, OpenEditorFlags flags)
+Core::IEditor *EditorManager::placeEditor(Core::Internal::EditorView *view, Core::IEditor *editor)
 {
-    if (flags & NoActivate)
-        return;
-
     Q_ASSERT(view && editor)            ;
-
-    qDebug() << "activateEditor" << editor->file()->fileName() << view;
     if (!view->hasEditor(editor)) {
-        qDebug() << "not in requested view";
         bool duplicateSupported = editor->duplicateSupported();
-        qDebug() << "duplicateSupported" << duplicateSupported;
         if (SplitterOrView *sourceView = m_d->m_splitter->findView(editor)) {
-            qDebug() << "found editor in another view";
             if (editor != sourceView->editor() || !duplicateSupported) {
-                qDebug() << "steal editor";
                 sourceView->view()->removeEditor(editor);
+                view->addEditor(editor);
+                view->setCurrentEditor(editor);
+                if (!sourceView->editor()) {
+                    if (IEditor *replacement = pickUnusedEditor()) {
+                        sourceView->view()->addEditor(replacement);
+                    }
+                }
+                return editor;
             } else if (duplicateSupported) {
-                qDebug() << "do duplicate";
                 editor = duplicateEditor(editor);
                 Q_ASSERT(editor);
             }
         }
         view->addEditor(editor);
-        view->setCurrentEditor(editor);
+    }
+    return editor;
 }
 
+void EditorManager::activateEditor(Core::Internal::EditorView *view, Core::IEditor *editor, OpenEditorFlags flags)
+{
+    Q_ASSERT(view)            ;
+
+    if (!editor && !m_d->m_currentEditor) {
+        setCurrentEditor(0, (flags & IgnoreNavigationHistory));
+        return;
+    }
+
+    bool hasCurrent = (view->currentEditor() != 0);
+    editor = placeEditor(view, editor);
+    if (!(flags & NoActivate) || !hasCurrent)
+        view->setCurrentEditor(editor);
+
+    if (!(flags & NoActivate)) {
         setCurrentEditor(editor, (flags & IgnoreNavigationHistory));
         ensureEditorManagerVisible();
         editor->widget()->setFocus();
-
-#if 0
-    if (!editor->duplicateSupported()) {
-        unsplitAll();
-        view = m_d->m_view;
     }
-
-    if (view == m_d->m_view || view->hasEditor(editor)) {
-        view->setCurrentEditor(editor);
-        return editor;
-    }
-    QList<IEditor*> editors = view->editors();
-    IEditor *duplicate = duplicateEditor(editor);
-    view->addEditor(duplicate);
-    view->setCurrentEditor(duplicate, ignoreNavigationHistory);
-    foreach(IEditor *e, editors) {
-        view->removeEditor(e);
-        closeDuplicate(e, true);
-    }
-    return duplicate;
-#endif
 }
 
 /* Find editors for a mimetype, best matching at the front
@@ -1573,11 +1670,14 @@ Core::IEditor *EditorManager::duplicateEditor(Core::IEditor *editor)
 
 void EditorManager::split(Qt::Orientation orientation)
 {
-    SplitterOrView *view = m_d->m_currentEditor ? m_d->m_splitter->findView(m_d->m_currentEditor)
+    SplitterOrView *view = m_d->m_currentView;
+    if (!view)
+            view = m_d->m_currentEditor ? m_d->m_splitter->findView(m_d->m_currentEditor)
                        : m_d->m_splitter->findFirstView();
     if (view)
         view->split(orientation);
 }
+
 void EditorManager::split()
 {
     split(Qt::Vertical);
@@ -1590,32 +1690,33 @@ void EditorManager::splitSideBySide()
 
 void EditorManager::unsplit()
 {
-    qDebug() << "unsplit" << (m_d->m_currentEditor ? m_d->m_currentEditor->file()->fileName() : QString("no current editor"));
-    SplitterOrView *splitter = m_d->m_currentEditor ? m_d->m_splitter->findSplitter(m_d->m_currentEditor) : m_d->m_splitter;
-    qDebug() << "splitter" << splitter;
-    if (splitter)
-        splitter->unsplit(m_d->m_currentEditor);
-}
+    SplitterOrView *viewToClose = m_d->m_currentView;
+    if (!viewToClose && m_d->m_currentEditor)
+        viewToClose = m_d->m_splitter->findView(m_d->m_currentEditor);
 
-void EditorManager::unsplitAll()
-{
-    m_d->m_splitter->unsplit(0);
-    if (IEditor *e = m_d->m_splitter->editor())
-        activateEditor(e);
+    if (!viewToClose || viewToClose->isSplitter() || viewToClose == m_d->m_splitter)
+        return;
+
+    closeView(viewToClose->view());
 }
 
 void EditorManager::gotoOtherWindow()
 {
-    if (!m_d->m_currentEditor)
-        return;
     if (m_d->m_splitter->isSplitter()) {
-        SplitterOrView *view = m_d->m_splitter->findNextView(m_d->m_currentEditor);
+        SplitterOrView *currentView = m_d->m_currentView;
+        if (!currentView && m_d->m_currentEditor)
+            currentView = m_d->m_splitter->findView(m_d->m_currentEditor);
+        if (!currentView)
+            currentView = m_d->m_splitter->findFirstView();
+        SplitterOrView *view = m_d->m_splitter->findNextView(currentView);
         if (!view)
             view = m_d->m_splitter->findFirstView();
         if (view) {
             if (IEditor *editor = view->editor()) {
                 setCurrentEditor(editor);
                 editor->widget()->setFocus();
+            } else {
+                setCurrentView(view);
             }
         }
     }

src/plugins/coreplugin/editormanager/editormanager.h

@@ -209,7 +209,6 @@ private slots:
     void split();
     void splitSideBySide();
     void unsplit();
-    void unsplitAll();
     void gotoOtherWindow();
 
 private:
@@ -221,11 +220,16 @@ private:
 
     void restoreEditorState(IEditor *editor);
 
+    IEditor *placeEditor(Core::Internal::EditorView *view, Core::IEditor *editor);
     Core::IEditor *duplicateEditor(IEditor *editor);
     void setCurrentEditor(IEditor *editor, bool ignoreNavigationHistory = false);
+    void setCurrentView(Core::Internal::SplitterOrView *view);
+    Core::Internal::SplitterOrView *currentView() const;
     void activateEditor(Core::Internal::EditorView *view, Core::IEditor *editor, OpenEditorFlags flags = 0);
     void closeEditor(Core::IEditor *editor);
     void closeView(Core::Internal::EditorView *view);
+    void emptyView(Core::Internal::EditorView *view);
+    IEditor *pickUnusedEditor() const;
 
     static EditorManager *m_instance;
     EditorManagerPrivate *m_d;

src/plugins/coreplugin/editormanager/editorview.cpp

@@ -265,7 +265,7 @@ EditorView::EditorView(EditorModel *model, QWidget *parent) :
 
         connect(m_editorList, SIGNAL(activated(int)), this, SLOT(listSelectionActivated(int)));
         connect(m_lockButton, SIGNAL(clicked()), this, SLOT(makeEditorWritable()));
-        connect(m_closeButton, SIGNAL(clicked()), this, SLOT(closeView()));
+        connect(m_closeButton, SIGNAL(clicked()), this, SLOT(closeView()), Qt::QueuedConnection);
     }
     {
         m_infoWidget->setFrameStyle(QFrame::Panel | QFrame::Raised);
@@ -343,11 +343,8 @@ void EditorView::addEditor(IEditor *editor)
     }
     connect(editor, SIGNAL(changed()), this, SLOT(checkEditorStatus()));
 
-    if (m_container->count() == 1) {
-        m_editorList->setCurrentIndex(qobject_cast<EditorModel*>(m_editorList->model())->indexOf(editor->file()->fileName()).row());
-        updateEditorStatus(editor);
-        updateToolBar(editor);
-    }
+    if (editor == currentEditor())
+        setCurrentEditor(editor);
 }
 
 bool EditorView::hasEditor(IEditor *editor) const
@@ -367,6 +364,7 @@ void EditorView::removeEditor(IEditor *editor)
 {
     QTC_ASSERT(editor, return);
     const int index = m_container->indexOf(editor->widget());
+    bool wasCurrent = (index == m_container->currentIndex());
     if (index != -1) {
         m_container->removeWidget(editor->widget());
         m_widgetEditorMap.remove(editor->widget());
@@ -383,6 +381,8 @@ void EditorView::removeEditor(IEditor *editor)
             toolBar->setParent(0);
         }
     }
+    if (wasCurrent)
+        setCurrentEditor(currentEditor());
 }
 
 IEditor *EditorView::currentEditor() const
@@ -480,18 +480,18 @@ void EditorView::listSelectionActivated(int index)
 }
 
 
-SplitterOrView::SplitterOrView(EditorView *view, QWidget *parent)
-        : QWidget(parent)
+
+SplitterOrView::SplitterOrView(Internal::EditorModel *model)
 {
-    m_isRoot = true;
+    m_isRoot = false;
     m_layout = new QStackedLayout(this);
-    m_view = view;
+    m_view = new EditorView(model ? model : CoreImpl::instance()->editorManager()->openedEditorsModel());
     m_splitter = 0;
     m_layout->addWidget(m_view);
+    setFocusPolicy(Qt::ClickFocus);
 }
 
-SplitterOrView::SplitterOrView(Core::IEditor *editor, QWidget *parent)
-        : QWidget(parent)
+SplitterOrView::SplitterOrView(Core::IEditor *editor)
 {
     m_isRoot = false;
     m_layout = new QStackedLayout(this);
@@ -499,8 +499,53 @@ SplitterOrView::SplitterOrView(Core::IEditor *editor, QWidget *parent)
     m_view->addEditor(editor);
     m_splitter = 0;
     m_layout->addWidget(m_view);
+    setFocusPolicy(Qt::ClickFocus);
 }
 
+void SplitterOrView::focusInEvent(QFocusEvent *)
+{
+    CoreImpl::instance()->editorManager()->setCurrentView(this);
+}
+
+void SplitterOrView::paintEvent(QPaintEvent *)
+{
+    if  (CoreImpl::instance()->editorManager()->currentView() != this)
+        return;
+    QPainter painter(this);
+
+    // Discreet indication where an editor would be
+    painter.setRenderHint(QPainter::Antialiasing, true);
+    painter.setPen(Qt::NoPen);
+    QColor shadeBrush(Qt::black);
+    shadeBrush.setAlpha(10);
+    painter.setBrush(shadeBrush);
+    const int r = 3;
+    painter.drawRoundedRect(rect().adjusted(r, r, -r, -r), r * 2, r * 2);
+
+    if (hasFocus()) {
+#ifdef Q_WS_MAC
+        // With QMacStyle, we have to draw our own focus rect, since I didn't find
+        // a way to draw the nice mac focus rect _inside_ this widget
+        if (qobject_cast<QMacStyle *>(style())) {
+            painter.setPen(Qt::DotLine);
+            painter.setBrush(Qt::NoBrush);
+            painter.setOpacity(0.75);
+            painter.drawRect(rect());
+        } else {
+#endif
+            QStyleOptionFocusRect option;
+            option.initFrom(this);
+            option.backgroundColor = palette().color(QPalette::Background);
+
+            // Some styles require a certain state flag in order to draw the focus rect
+            option.state |= QStyle::State_KeyboardFocusChange;
+
+            style()->drawPrimitive(QStyle::PE_FrameFocusRect, &option, &painter);
+#ifdef Q_WS_MAC
+        }
+#endif
+    }
+}
 
 SplitterOrView *SplitterOrView::findFirstView()
 {
@@ -515,6 +560,21 @@ SplitterOrView *SplitterOrView::findFirstView()
     return this;
 }
 
+SplitterOrView *SplitterOrView::findEmptyView()
+{
+    if (m_splitter) {
+        for (int i = 0; i < m_splitter->count(); ++i) {
+            if (SplitterOrView *splitterOrView = qobject_cast<SplitterOrView*>(m_splitter->widget(i)))
+                if (SplitterOrView *result = splitterOrView->findEmptyView())
+                    return result;
+        }
+        return 0;
+    }
+    if (!hasEditors())
+        return this;
+    return 0;
+}
+
 SplitterOrView *SplitterOrView::findView(Core::IEditor *editor)
 {
     if (!editor || hasEditor(editor))
@@ -529,6 +589,20 @@ SplitterOrView *SplitterOrView::findView(Core::IEditor *editor)
     return 0;
 }
 
+SplitterOrView *SplitterOrView::findView(EditorView *view)
+{
+    if (view == m_view)
+        return this;
+    if (m_splitter) {
+        for (int i = 0; i < m_splitter->count(); ++i) {
+            if (SplitterOrView *splitterOrView = qobject_cast<SplitterOrView*>(m_splitter->widget(i)))
+                if (SplitterOrView *result = splitterOrView->findView(view))
+                    return result;
+        }
+    }
+    return 0;
+}
+
 SplitterOrView *SplitterOrView::findSplitter(Core::IEditor *editor)
 {
     if (m_splitter) {
@@ -559,19 +633,19 @@ SplitterOrView *SplitterOrView::findSplitter(SplitterOrView *child)
     return 0;
 }
 
-SplitterOrView *SplitterOrView::findNextView(Core::IEditor *editor)
+SplitterOrView *SplitterOrView::findNextView(SplitterOrView *view)
 {
     bool found = false;
-    return findNextView_helper(editor, &found);
+    return findNextView_helper(view, &found);
 }
 
-SplitterOrView *SplitterOrView::findNextView_helper(Core::IEditor *editor, bool *found)
+SplitterOrView *SplitterOrView::findNextView_helper(SplitterOrView *view, bool *found)
 {
     if (*found && m_view) {
         return this;
     }
 
-    if (hasEditor(editor)) {
+    if (this == view) {
         *found = true;
         return 0;
     }
@@ -579,7 +653,7 @@ SplitterOrView *SplitterOrView::findNextView_helper(Core::IEditor *editor, bool
     if (m_splitter) {
         for (int i = 0; i < m_splitter->count(); ++i) {
             if (SplitterOrView *splitterOrView = qobject_cast<SplitterOrView*>(m_splitter->widget(i))) {
-                if (SplitterOrView *result = splitterOrView->findNextView_helper(editor, found))
+                if (SplitterOrView *result = splitterOrView->findNextView_helper(view, found))
                     return result;
             }
         }
@@ -592,32 +666,46 @@ void SplitterOrView::split(Qt::Orientation orientation)
     Q_ASSERT(m_view && m_splitter == 0);
     m_splitter = new QSplitter(this);
     m_splitter->setOrientation(orientation);
+    m_layout->addWidget(m_splitter);
+    EditorManager *em = CoreImpl::instance()->editorManager();
     Core::IEditor *e = m_view->currentEditor();
 
-    SplitterOrView *focusView = 0;
+    if (e) {
 
         m_view->removeEditor(e);
-    m_splitter->addWidget((focusView = new SplitterOrView(e)));
-
-    Core::IEditor *duplicate = CoreImpl::instance()->editorManager()->duplicateEditor(e);
-    m_splitter->addWidget(new SplitterOrView(duplicate));
-    m_layout->addWidget(m_splitter);
-
-    if (!m_isRoot) {
-        delete m_view;
+        m_splitter->addWidget(new SplitterOrView(e));
         m_view = 0;
+
+        if (e->duplicateSupported()) {
+            Core::IEditor *duplicate = em->duplicateEditor(e);
+            m_splitter->addWidget(new SplitterOrView(duplicate));
         } else {
-        m_layout->setCurrentWidget(m_splitter);
+            m_splitter->addWidget(new SplitterOrView());
+        }
+    } else {
+        m_splitter->addWidget(new SplitterOrView());
+        m_splitter->addWidget(new SplitterOrView());
     }
 
-    CoreImpl::instance()->editorManager()->activateEditor(e);
+    m_layout->setCurrentWidget(m_splitter);
+
+    if (m_view && !m_isRoot) {
+        em->emptyView(m_view);
+        delete m_view;
+        m_view = 0;
+    }
+
+    if (e)
+        em->activateEditor(e);
+    else
+        em->setCurrentView(findFirstView());
 }
 
 void SplitterOrView::close()
 {
     Q_ASSERT(!m_isRoot);
     if (m_view) {
-        m_view->closeView();
+        CoreImpl::instance()->editorManager()->emptyView(m_view);
         delete m_view;
         m_view = 0;
     }
@@ -635,7 +723,7 @@ void SplitterOrView::closeSplitterEditors()
     }
 }
 
-void SplitterOrView::unsplit(Core::IEditor *editor)
+void SplitterOrView::unsplit()
 {
     if (!m_splitter)
         return;

src/plugins/coreplugin/editormanager/editorview.h

@@ -151,33 +151,43 @@ class SplitterOrView  : public QWidget
 {
     Q_OBJECT
 public:
-    SplitterOrView(EditorView *view, QWidget *parent = 0); // creates a root splitter or view
-    SplitterOrView(Core::IEditor *editor, QWidget *parent = 0);
+    SplitterOrView(Internal::EditorModel *model = 0); // creates a splitter with an empty view
+    SplitterOrView(Core::IEditor *editor);
 
     void split(Qt::Orientation orientation);
-    void unsplit(Core::IEditor *editor);
+    void unsplit();
 
-    bool isView() const { return m_view != 0; }
-    bool isRoot() const { return m_isRoot; }
+    inline bool isView() const { return m_view != 0; }
+    inline void setRoot(bool b) { m_isRoot = b; }
+    inline bool isRoot() const { return m_isRoot; }
+    
+    inline bool isSplitter() const { return m_splitter != 0; }
+    inline Core::IEditor *editor() const { return m_view ? m_view->currentEditor() : 0; }
+    inline QList<Core::IEditor *> editors() const { return m_view ? m_view->editors() : QList<Core::IEditor*>(); }
+    inline bool hasEditor(Core::IEditor *editor) const { return m_view && m_view->hasEditor(editor); }
+    inline bool hasEditors() const { return m_view && m_view->editorCount() != 0; }
+    inline EditorView *view() const { return m_view; }
+    inline QSplitter *splitter() const { return m_splitter; }
 
-    bool isSplitter() const { return m_splitter != 0; }
-    Core::IEditor *editor() const { return m_view ? m_view->currentEditor() : 0; }
-    QList<Core::IEditor *> editors() const { return m_view ? m_view->editors() : QList<Core::IEditor*>(); }
-    bool hasEditor(Core::IEditor *editor) const { return m_view && m_view->hasEditor(editor); }
-    EditorView *view() const { return m_view; }
-    QSplitter *splitter() const { return m_splitter; }
 
     SplitterOrView *findView(Core::IEditor *editor);
+    SplitterOrView *findView(EditorView *view);
     SplitterOrView *findFirstView();
+    SplitterOrView *findEmptyView();
     SplitterOrView *findSplitter(Core::IEditor *editor);
     SplitterOrView *findSplitter(SplitterOrView *child);
 
-    SplitterOrView *findNextView(Core::IEditor *editor);
+    SplitterOrView *findNextView(SplitterOrView *view);
+
+protected:
+    void focusInEvent(QFocusEvent *);
+    void paintEvent(QPaintEvent *);
+
 
 private:
     void close();
     void closeSplitterEditors();
-    SplitterOrView *findNextView_helper(Core::IEditor *editor, bool *found);
+    SplitterOrView *findNextView_helper(SplitterOrView *view, bool *found);
     bool m_isRoot;
     QStackedLayout *m_layout;
     EditorView *m_view;

src/plugins/coreplugin/editormanager/openeditorswindow.cpp

@@ -235,6 +235,7 @@ void OpenEditorsWindow::selectEditor(QTreeWidgetItem *item)
     IEditor *editor = 0;
     if (item)
         editor = item->data(0, Qt::UserRole).value<IEditor*>();
+    if (editor)
         EditorManager::instance()->activateEditor(editor);
 }