comparison view/PaneStack.cpp @ 1266:a34a2a25907c

Untabify

     av->setViewManager(m_viewManager);
     layout->addWidget(av, 2, 1);
 
     QWidget *properties = 0;
     if (suppressPropertyBox) {
-	properties = new QFrame();
+        properties = new QFrame();
     } else {
-	properties = new PropertyStack(frame, pane);
-	connect(properties, SIGNAL(propertyContainerSelected(View *, PropertyContainer *)),
-		this, SLOT(propertyContainerSelected(View *, PropertyContainer *)));
+        properties = new PropertyStack(frame, pane);
+        connect(properties, SIGNAL(propertyContainerSelected(View *, PropertyContainer *)),
+                this, SLOT(propertyContainerSelected(View *, PropertyContainer *)));
         connect(properties, SIGNAL(viewSelected(View  *)),
                 this, SLOT(viewSelected(View *)));
         connect(properties, SIGNAL(contextHelpChanged(const QString &)),
                 this, SIGNAL(contextHelpChanged(const QString &)));
     }

 
     frame->setLayout(layout);
     m_splitter->insertWidget(index, frame);
 
     connect(pane, SIGNAL(propertyContainerAdded(PropertyContainer *)),
-	    this, SLOT(propertyContainerAdded(PropertyContainer *)));
+            this, SLOT(propertyContainerAdded(PropertyContainer *)));
     connect(pane, SIGNAL(propertyContainerRemoved(PropertyContainer *)),
-	    this, SLOT(propertyContainerRemoved(PropertyContainer *)));
+            this, SLOT(propertyContainerRemoved(PropertyContainer *)));
     connect(pane, SIGNAL(paneInteractedWith()),
-	    this, SLOT(paneInteractedWith()));
+            this, SLOT(paneInteractedWith()));
     connect(pane, SIGNAL(rightButtonMenuRequested(QPoint)),
             this, SLOT(rightButtonMenuRequested(QPoint)));
     connect(pane, SIGNAL(dropAccepted(QStringList)),
             this, SLOT(paneDropAccepted(QStringList)));
     connect(pane, SIGNAL(dropAccepted(QString)),

 
     emit paneAdded(pane);
     emit paneAdded();
 
     if (!m_currentPane) {
-	setCurrentPane(pane);
+        setCurrentPane(pane);
     }
 
     showOrHidePaneAccessories();
     relinkAlignmentViews();
 

     bool found = false;
 
     QWidget *stack = 0;
 
     for (i = m_panes.begin(); i != m_panes.end(); ++i) {
-	if (i->pane == pane) {
+        if (i->pane == pane) {
             stack = i->propertyStack;
-	    m_panes.erase(i);
-	    found = true;
-	    break;
-	}
+            m_panes.erase(i);
+            found = true;
+            break;
+        }
     }
 
     if (!found) {
 
-	for (i = m_hiddenPanes.begin(); i != m_hiddenPanes.end(); ++i) {
-	    if (i->pane == pane) {
+        for (i = m_hiddenPanes.begin(); i != m_hiddenPanes.end(); ++i) {
+            if (i->pane == pane) {
                 stack = i->propertyStack;
-		m_hiddenPanes.erase(i);
-		found = true;
-		break;
-	    }
-	}
-
-	if (!found) {
-	    cerr << "WARNING: PaneStack::deletePane(" << pane << "): Pane not found in visible or hidden panes, not deleting" << endl;
-	    return;
-	}
+                m_hiddenPanes.erase(i);
+                found = true;
+                break;
+            }
+        }
+
+        if (!found) {
+            cerr << "WARNING: PaneStack::deletePane(" << pane << "): Pane not found in visible or hidden panes, not deleting" << endl;
+            return;
+        }
     }
 
     emit paneAboutToBeDeleted(pane);
     unlinkAlignmentViews();
 

     delete stack;
 
     delete pane->parent();
 
     if (m_currentPane == pane) {
-	if (m_panes.size() > 0) {
+        if (m_panes.size() > 0) {
             setCurrentPane(m_panes[0].pane);
-	} else {
-	    setCurrentPane(0);
-	}
+        } else {
+            setCurrentPane(0);
+        }
     }
 
     showOrHidePaneAccessories();
     relinkAlignmentViews();
 

 PaneStack::hidePane(Pane *pane)
 {
     std::vector<PaneRec>::iterator i = m_panes.begin();
 
     while (i != m_panes.end()) {
-	if (i->pane == pane) {
-
-	    m_hiddenPanes.push_back(*i);
-	    m_panes.erase(i);
-
-	    QWidget *pw = dynamic_cast<QWidget *>(pane->parent());
-	    if (pw) pw->hide();
-
-	    if (m_currentPane == pane) {
-		if (m_panes.size() > 0) {
-		    setCurrentPane(m_panes[0].pane);
-		} else {
-		    setCurrentPane(0);
-		}
-	    }
-	    
+        if (i->pane == pane) {
+
+            m_hiddenPanes.push_back(*i);
+            m_panes.erase(i);
+
+            QWidget *pw = dynamic_cast<QWidget *>(pane->parent());
+            if (pw) pw->hide();
+
+            if (m_currentPane == pane) {
+                if (m_panes.size() > 0) {
+                    setCurrentPane(m_panes[0].pane);
+                } else {
+                    setCurrentPane(0);
+                }
+            }
+            
             showOrHidePaneAccessories();
             emit paneHidden(pane);
             emit paneHidden();
-	    return;
-	}
-	++i;
+            return;
+        }
+        ++i;
     }
 
     relinkAlignmentViews();
 
     cerr << "WARNING: PaneStack::hidePane(" << pane << "): Pane not found in visible panes" << endl;

 PaneStack::showPane(Pane *pane)
 {
     std::vector<PaneRec>::iterator i = m_hiddenPanes.begin();
 
     while (i != m_hiddenPanes.end()) {
-	if (i->pane == pane) {
-	    m_panes.push_back(*i);
-	    m_hiddenPanes.erase(i);
-	    QWidget *pw = dynamic_cast<QWidget *>(pane->parent());
-	    if (pw) pw->show();
-
-	    //!!! update current pane
+        if (i->pane == pane) {
+            m_panes.push_back(*i);
+            m_hiddenPanes.erase(i);
+            QWidget *pw = dynamic_cast<QWidget *>(pane->parent());
+            if (pw) pw->show();
+
+            //!!! update current pane
 
             showOrHidePaneAccessories();
 
-	    return;
-	}
-	++i;
+            return;
+        }
+        ++i;
     }
 
     relinkAlignmentViews();
 
     cerr << "WARNING: PaneStack::showPane(" << pane << "): Pane not found in hidden panes" << endl;

     unselectedMap.fill(QApplication::palette().color(QPalette::Background));
 
     bool found = false;
 
     while (i != m_panes.end()) {
-	if (i->pane == pane) {
-	    i->currentIndicator->setPixmap(selectedMap);
+        if (i->pane == pane) {
+            i->currentIndicator->setPixmap(selectedMap);
             if (m_layoutStyle != PropertyStackPerPaneLayout) {
                 m_propertyStackStack->setCurrentWidget(i->propertyStack);
             }
-	    found = true;
-	} else {
-	    i->currentIndicator->setPixmap(unselectedMap);
-	}
-	++i;
+            found = true;
+        } else {
+            i->currentIndicator->setPixmap(unselectedMap);
+        }
+        ++i;
     }
 
     if (found || pane == 0) {
-	m_currentPane = pane;
-	emit currentPaneChanged(m_currentPane);
+        m_currentPane = pane;
+        emit currentPaneChanged(m_currentPane);
     } else {
-	cerr << "WARNING: PaneStack::setCurrentPane(" << pane << "): pane is not a visible pane in this stack" << endl;
+        cerr << "WARNING: PaneStack::setCurrentPane(" << pane << "): pane is not a visible pane in this stack" << endl;
     }
 }
 
 void
 PaneStack::setCurrentLayer(Pane *pane, Layer *layer) // may be null
 {
     setCurrentPane(pane);
 
     if (m_currentPane) {
 
-	std::vector<PaneRec>::iterator i = m_panes.begin();
-
-	while (i != m_panes.end()) {
-
-	    if (i->pane == pane) {
-		PropertyStack *stack = dynamic_cast<PropertyStack *>
-		    (i->propertyStack);
-		if (stack) {
-		    if (stack->containsContainer(layer)) {
-			stack->setCurrentIndex(stack->getContainerIndex(layer));
-			emit currentLayerChanged(pane, layer);
-		    } else {
-			stack->setCurrentIndex
-			    (stack->getContainerIndex
-			     (pane->getPropertyContainer(0)));
-			emit currentLayerChanged(pane, 0);
-		    }
-		}
-		break;
-	    }
-	    ++i;
-	}
+        std::vector<PaneRec>::iterator i = m_panes.begin();
+
+        while (i != m_panes.end()) {
+
+            if (i->pane == pane) {
+                PropertyStack *stack = dynamic_cast<PropertyStack *>
+                    (i->propertyStack);
+                if (stack) {
+                    if (stack->containsContainer(layer)) {
+                        stack->setCurrentIndex(stack->getContainerIndex(layer));
+                        emit currentLayerChanged(pane, layer);
+                    } else {
+                        stack->setCurrentIndex
+                            (stack->getContainerIndex
+                             (pane->getPropertyContainer(0)));
+                        emit currentLayerChanged(pane, 0);
+                    }
+                }
+                break;
+            }
+            ++i;
+        }
     }
 }
 
 Pane *
 PaneStack::getCurrentPane() 

 PaneStack::propertyContainerSelected(View *client, PropertyContainer *pc)
 {
     std::vector<PaneRec>::iterator i = m_panes.begin();
 
     while (i != m_panes.end()) {
-	PropertyStack *stack = dynamic_cast<PropertyStack *>(i->propertyStack);
-	if (stack &&
-	    stack->getClient() == client &&
-	    stack->containsContainer(pc)) {
-	    setCurrentPane(i->pane);
-	    break;
-	}
-	++i;
+        PropertyStack *stack = dynamic_cast<PropertyStack *>(i->propertyStack);
+        if (stack &&
+            stack->getClient() == client &&
+            stack->containsContainer(pc)) {
+            setCurrentPane(i->pane);
+            break;
+        }
+        ++i;
     }
 
     Layer *layer = dynamic_cast<Layer *>(pc);
     if (layer) emit currentLayerChanged(m_currentPane, layer);
     else emit currentLayerChanged(m_currentPane, 0);

     int maxMinWidth = 0;
 
     if (m_propertyStackMinWidth > 0) maxMinWidth = m_propertyStackMinWidth;
 
     for (int i = 0; i < (int)m_panes.size(); ++i) {
-	if (!m_panes[i].propertyStack) continue;
+        if (!m_panes[i].propertyStack) continue;
 #ifdef DEBUG_PANE_STACK
-	SVDEBUG << "PaneStack::sizePropertyStacks: " << i << ": min " 
-		  << m_panes[i].propertyStack->minimumSizeHint().width() << ", hint "
+        SVDEBUG << "PaneStack::sizePropertyStacks: " << i << ": min " 
+                  << m_panes[i].propertyStack->minimumSizeHint().width() << ", hint "
                   << m_panes[i].propertyStack->sizeHint().width() << ", current "
-		  << m_panes[i].propertyStack->width() << endl;
+                  << m_panes[i].propertyStack->width() << endl;
 #endif
 
-	if (m_panes[i].propertyStack->sizeHint().width() > maxMinWidth) {
-	    maxMinWidth = m_panes[i].propertyStack->sizeHint().width();
-	}
+        if (m_panes[i].propertyStack->sizeHint().width() > maxMinWidth) {
+            maxMinWidth = m_panes[i].propertyStack->sizeHint().width();
+        }
     }
 
 #ifdef DEBUG_PANE_STACK
     SVDEBUG << "PaneStack::sizePropertyStacks: max min width " << maxMinWidth << endl;
 #endif

     int setWidth = maxMinWidth;
 
     m_propertyStackStack->setMaximumWidth(setWidth + 10);
 
     for (int i = 0; i < (int)m_panes.size(); ++i) {
-	if (!m_panes[i].propertyStack) continue;
-	m_panes[i].propertyStack->setMinimumWidth(setWidth);
+        if (!m_panes[i].propertyStack) continue;
+        m_panes[i].propertyStack->setMinimumWidth(setWidth);
     }
 
     emit propertyStacksResized(setWidth);
     emit propertyStacksResized();
 }

 void
 PaneStack::paneDeleteButtonClicked()
 {
     QObject *s = sender();
     for (int i = 0; i < (int)m_panes.size(); ++i) {
-	if (m_panes[i].xButton == s) {
+        if (m_panes[i].xButton == s) {
             emit paneDeleteButtonClicked(m_panes[i].pane);
         }
     }
 }
 

 PaneStack::indicatorClicked()
 {
     QObject *s = sender();
 
     for (int i = 0; i < (int)m_panes.size(); ++i) {
-	if (m_panes[i].currentIndicator == s) {
+        if (m_panes[i].currentIndicator == s) {
             setCurrentPane(m_panes[i].pane);
             return;
         }
     }
 }