C++ QSplitter::count方法代码示例

void SplitView::split(BufferView* view, Qt::Orientation orientation)
{
    if (view) {
        QSplitter* container = qobject_cast<QSplitter*>(view->parentWidget());
        if (container) {
            int index = container->indexOf(view);
            BufferView* bv = 0;
            const int size = (orientation == Qt::Horizontal ? container->width() : container->height()) - container->handleWidth();
            if (container->count() == 1 || container->orientation() == orientation) {
                container->setOrientation(orientation);
                bv = createBufferView(container, index + 1);
                QList<int> sizes;
                for (int i = 0; i < container->count(); ++i)
                    sizes += size / container->count();
                container->setSizes(sizes);
            } else if (index != -1) {
                QList<int> sizes = container->sizes();
                QSplitter* splitter = wrap(view, orientation);
                if (splitter) {
                    container->setSizes(sizes);
                    bv = createBufferView(splitter);
                    splitter->setSizes(QList<int>() << size/2 << size/2);
                }
            }
            if (bv) {
                bv->setBuffer(view->buffer());
                emit viewAdded(bv);
            }
        }
    }
}

QSplitter* ScoreTab::viewSplitter(int n) const
{
    TabScoreView* tsv = static_cast<TabScoreView*>(tab->tabData(n).value<void*>());
    if (tsv == 0) {
        // qDebug("ScoreTab::viewSplitter %d is zero", n);
        return 0;
    }
    Score* score = tsv->score;
    if (tsv->part) {
        QList<Excerpt*>& excerpts = score->excerpts();
        if (!excerpts.isEmpty() && ((tsv->part - 1) < excerpts.size()))
            score = excerpts.at(tsv->part - 1)->partScore();
    }

    int nn = stack->count();
    for (int i = 0; i < nn; ++i) {
        QSplitter* sp = static_cast<QSplitter*>(stack->widget(i));
        if (sp->count() == 0)
            return 0;
        ScoreView* v = static_cast<ScoreView*>(sp->widget(0));
        if (v->score() == score)
            return sp;
    }
    return 0;
}

    bool eventFilter(QObject* obj, QEvent* event) override
    {
        // check input
        if (event->type() != QEvent::MouseButtonDblClick)
            return false;

         QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(event);
         if (mouseEvent->button() != Qt::LeftButton)
             return false;

        QSplitterHandle* splitterHandle = qobject_cast<QSplitterHandle*>(obj);
        if (!splitterHandle)
            return false;

        QSplitter* splitter = splitterHandle->splitter();
        if (!splitter || splitter->count() < 2)
            return false;

        // change splitter sizes to make description panel occupy ideal height
        QWidget* bottomWidget = splitter->widget(1);
        QList<int> sizes = splitter->sizes();
        if (sizes.size() != 2)
            return false;

        sizes[0] += sizes[1];
        sizes[1] = bottomWidget->heightForWidth(bottomWidget->size().width());
        sizes[0] -= qMax(sizes[1], 0);

        splitter->setSizes(sizes);

        return true;
    }

DockTabMotherWidget::TabWidgetArea DockTabMotherWidget::dropAreaAt(const QPoint &pos, Direction dir)
{
	int countSplitter = _splitterLists[dir].size();
	
	for (int indexSplitter = 0; indexSplitter < countSplitter; ++indexSplitter)
	{
		QSplitter *splitter = _splitterLists[dir].at(indexSplitter);
		
		int countTabWidget = splitter->count();
		
		for (int indexTabWidget = 0; indexTabWidget < countTabWidget; ++indexTabWidget)
		{
			InsertionDirection insertionDir;
			
			if (getInsertionDirection(pos, splitter->widget(indexTabWidget), dir, insertionDir))
			{
				switch (insertionDir)
				{
					case NextSplitter:
						return TabWidgetArea(dir, indexSplitter + 1, -1);
					case PreviousSplitter:
						return TabWidgetArea(dir, indexSplitter, -1);
					case Next:
						return TabWidgetArea(dir, indexSplitter, indexTabWidget + 1);
					case Previous:
						return TabWidgetArea(dir, indexSplitter, indexTabWidget);
					default:
						break;
				}
			}
		}
	}
	return TabWidgetArea();
}

void KateViewManager::splitViewSpace( KateViewSpace* vs, // = 0
    Qt::Orientation o )// = Qt::Horizontal
{
  // emergency: fallback to activeViewSpace, and if still invalid, abort
  if (!vs) vs = activeViewSpace();
  if (!vs) return;

  // get current splitter, and abort if null
  QSplitter *currentSplitter = qobject_cast<QSplitter*>(vs->parentWidget());
  if (!currentSplitter) return;

  // index where to insert new splitter/viewspace
  const int index = currentSplitter->indexOf( vs );

  // create new viewspace
  KateViewSpace* vsNew = new KateViewSpace( this );

  // only 1 children -> we are the root container. So simply set the orientation
  // and add the new view space, then correct the sizes to 50%:50%
  if (currentSplitter->count() == 1)
  {
    if( currentSplitter->orientation() != o )
      currentSplitter->setOrientation( o );
    QList<int> sizes = currentSplitter->sizes();
    sizes << (sizes.first() - currentSplitter->handleWidth() ) / 2;
    sizes[0] = sizes[1];
    currentSplitter->insertWidget( index, vsNew );
    currentSplitter->setSizes( sizes );
  }
  else
  {
    // create a new QSplitter and replace vs with the splitter. vs and newVS are
    // the new children of the new QSplitter
    QSplitter* newContainer = new QSplitter( o );
    newContainer->setOpaqueResize( KGlobalSettings::opaqueResize() );
    QList<int> currentSizes = currentSplitter->sizes();

    newContainer->addWidget( vs );
    newContainer->addWidget( vsNew );
    currentSplitter->insertWidget( index, newContainer );
    newContainer->show();

    // fix sizes of children of old and new splitter
    currentSplitter->setSizes( currentSizes );
    QList<int> newSizes = newContainer->sizes();
    newSizes[0] = (newSizes[0] + newSizes[1] - newContainer->handleWidth()) / 2;
    newSizes[1] = newSizes[0];
    newContainer->setSizes( newSizes );
  }

  m_viewSpaceList.append( vsNew );
  activeViewSpace()->setActive( false );
  vsNew->setActive( true, true );
  vsNew->show();

  createView ((KTextEditor::Document*)activeView()->document());

  updateViewSpaceActions ();
}

QStackedWidget* SplitGrid2::getCellImp(int row, int col) const
{
    if( col < 0 || col >= count() )
		return 0;
	QSplitter* s = static_cast<QSplitter*>( QSplitter::widget( col ) );
	if( row < 0 || row >= s->count() )
		return 0;
	else
        return static_cast<QStackedWidget*>( s->widget( row ) );
}

void ViewAreaImpl::dropViewInsidePane(ViewPane* pane, View* view, int dropEdge)
{
    if(dropEdge == OVER){
        addView(pane, view, true);

    } else {
        QSize destSize = pane->size();

        QSplitter* parentSplitter = static_cast<QSplitter*>(pane->parentWidget());

        if(parentSplitter->count() >= 2){
            QList<int> sizes = parentSplitter->sizes();
            QSplitter* newSplitter = new QSplitter(parentSplitter);
            parentSplitter->insertWidget(parentSplitter->indexOf(pane), newSplitter);
            newSplitter->addWidget(pane);
            parentSplitter->setSizes(sizes);
            parentSplitter = newSplitter;
        }
        
        ViewPane* newViewPane = new ViewPane(this, parentSplitter);

        if(dropEdge == LEFT){
            parentSplitter->setOrientation(Qt::Horizontal);
            parentSplitter->insertWidget(0, newViewPane);
        } else if(dropEdge == RIGHT){
            parentSplitter->setOrientation(Qt::Horizontal);
            parentSplitter->insertWidget(1, newViewPane);
        } else if(dropEdge == TOP){
            parentSplitter->setOrientation(Qt::Vertical);
            parentSplitter->insertWidget(0, newViewPane);
        } else {
            parentSplitter->setOrientation(Qt::Vertical);
            parentSplitter->insertWidget(1, newViewPane);
        }
        addView(newViewPane, view, true);

        int half;
        if(parentSplitter->orientation() == Qt::Horizontal){
            half = destSize.height() / 2;
        } else {
            half = destSize.width() / 2;
        }
        QList<int> sizes;
        sizes << half << half;
        parentSplitter->setSizes(sizes);
    }
}

EditorView *EditorView::findNextView()
{
    SplitterOrView *current = parentSplitterOrView();
    QTC_ASSERT(current, return this);
    SplitterOrView *parent = current->findParentSplitter();
    while (parent) {
        QSplitter *splitter = parent->splitter();
        QTC_ASSERT(splitter, return this);
        QTC_ASSERT(splitter->count() == 2, return this);
        // is current the first child? then the next view is the first one in current's sibling
        if (splitter->widget(0) == current) {
            SplitterOrView *second = qobject_cast<SplitterOrView *>(splitter->widget(1));
            QTC_ASSERT(second, return this);
            return second->findFirstView();
        }
        // otherwise go up the hierarchy
        current = parent;
        parent = current->findParentSplitter();
    }

void MultiViewWidget::removeView()
{
  ContainerWidget *container = qobject_cast<ContainerWidget *>(sender());
  if (container) {
    QSplitter *splitter = qobject_cast<QSplitter *>(container->parent());
    if (splitter && splitter->count() == 2) {
      // Get its parent, and insert the other widget into it, delete this widget.
      QSplitter *splitterParent = qobject_cast<QSplitter *>(splitter->parent());
      QWidget *moveWidget = splitter->widget(0);
      if (moveWidget == container)
        moveWidget = splitter->widget(1);
      setActiveWidget(moveWidget);
      if (splitterParent) {
        int idx = splitterParent->indexOf(splitter);
        splitterParent->insertWidget(idx, moveWidget);
        splitter->deleteLater();
      }
      else if (splitter->parent() == this) {
        // No more splits - back to single view widget.
        QVBoxLayout *layoutParent = qobject_cast<QVBoxLayout *>(layout());
        if (layoutParent) {
          layoutParent->addWidget(moveWidget);
          layoutParent->removeWidget(splitter);
          splitter->deleteLater();
        }
      }
    }
    else if (container->parent() == this) {
      // Delete the current container, and create the option container.
      QVBoxLayout *vLayout = qobject_cast<QVBoxLayout *>(layout());
      container->deleteLater();
      ContainerWidget *newContainer = createContainer();
      vLayout->addWidget(newContainer);
      setActiveWidget(newContainer);
    }
  }
}

void FrostEdit::closeTabWidgetFrame(TabWidgetFrame* tabWidFrame) {
	QWidget* parent = tabWidFrame->parentWidget();
	QSplitter* parentsplitter = qobject_cast<QSplitter*>(parent);
	if(tabWidFrame->tabWidget() == mCurrentTabWidget) mCurrentTabWidget = nullptr;
	if(parentsplitter != NULL) {

		for(int i = 0; i < tabWidFrame->tabWidget()->count(); i++) {
			closeTab(tabWidFrame->tabWidget(), i);
		}

		int index = mTabWidgetFrames.indexOf(tabWidFrame);
		mTabWidgetFrames.first()->tabWidget()->setActive(true);
		mTabWidgetFrames.remove(index);
		delete tabWidFrame;



		if(!parentsplitter->count() > 1) {
			FrostEdit* edit = qobject_cast<FrostEdit*>(parentsplitter->parentWidget());
			QSplitter* splitter = qobject_cast<QSplitter*>(parentsplitter->parentWidget());
			TabWidgetFrame* wid = toTabWidgetFrame(parentsplitter->widget(0));
			if(edit != nullptr && splitter == nullptr) {
				edit->setCentralWidget(wid);
				wid->setParent(edit);
			} else if (splitter != nullptr && edit == nullptr) {
				splitter->addWidget(wid);
				wid->setParent(splitter);
			}

			delete parentsplitter;
		}

	}


}

void ScoreTab::setCurrent(int n)
{
    if (n == -1) {
        clearTab2();
        tab2->setVisible(false);
        // clearTab2();      //??
        emit currentScoreViewChanged(0);
        return;
    }
    TabScoreView* tsv = static_cast<TabScoreView*>(tab->tabData(n).value<void*>());
    QSplitter* vs = viewSplitter(n);

    ScoreView* v;
    if (!vs) {
        vs = new QSplitter;
        v  = new ScoreView;
        tab2->blockSignals(true);
        tab2->setCurrentIndex(0);
        tab2->blockSignals(false);
        vs->addWidget(v);
        v->setScore(scoreList->value(n));
        stack->addWidget(vs);
    }
    else {
        v = static_cast<ScoreView*>(vs->widget(0));
    }
#ifdef OMR
    if (v) {
        Score* score = v->score();
        if (score->showOmr() && score->omr()) {
            if (vs->count() < 2) {
                Omr* omr    = score->omr();
                OmrView* sv = omr->newOmrView(v);
                v->setOmrView(sv);
                vs->addWidget(sv);
                connect(v, SIGNAL(scaleChanged(double)), sv, SLOT(setScale(double)));
                connect(v, SIGNAL(offsetChanged(double,double)), sv, SLOT(setOffset(double,double)));
                const QTransform _matrix = v->matrix();
                double _spatium = score->spatium();
                double scale = _matrix.m11() * _spatium;
                sv->setScale(scale);
                sv->setOffset(_matrix.dx(), _matrix.dy());
                QList<int> sizes;
                sizes << 100 << 100;
                vs->setSizes(sizes);
            }
        }
        else {
            if (vs->count() > 1) {
                QWidget* w = vs->widget(1);
                delete w;
            }
        }
    }
#endif
    stack->setCurrentWidget(vs);
    clearTab2();
    if (v) {
        Score* score = v->score();
        if (score->parentScore())
            score = score->parentScore();
        QList<Excerpt*>& excerpts = score->excerpts();
        if (!excerpts.isEmpty()) {
            tab2->blockSignals(true);
            tab2->addTab(score->name().replace("&","&&"));
            foreach(const Excerpt* excerpt, excerpts) {
                tab2->addTab(excerpt->partScore()->name().replace("&","&&"));
            }
            tab2->setCurrentIndex(tsv->part);
            tab2->blockSignals(false);
            tab2->setVisible(true);
        }

void KateViewManager::removeViewSpace (KateViewSpace *viewspace)
{
  // abort if viewspace is 0
  if (!viewspace) return;

  // abort if this is the last viewspace
  if (m_viewSpaceList.count() < 2) return;

  // get current splitter
  QSplitter *currentSplitter = qobject_cast<QSplitter*>(viewspace->parentWidget());

  // no splitter found, bah
  if (!currentSplitter)
    return;

  // delete views of the viewspace
  while (viewspace->viewCount() > 0 && viewspace->currentView())
  {
    deleteView( viewspace->currentView(), false );
  }

  // cu viewspace
  m_viewSpaceList.removeAt( m_viewSpaceList.indexOf( viewspace ) );
  delete viewspace;

  // at this point, the splitter has exactly 1 child
  Q_ASSERT( currentSplitter->count() == 1 );

  // if we are not the root splitter, move the child one level up and delete
  // the splitter then.
  if (currentSplitter != this)
  {
    // get parent splitter
    QSplitter *parentSplitter = qobject_cast<QSplitter*>(currentSplitter->parentWidget());

    // only do magic if found ;)
    if (parentSplitter)
    {
      int index = parentSplitter->indexOf (currentSplitter);

      // save current splitter size, as the removal of currentSplitter looses the info
      QList<int> parentSizes = parentSplitter->sizes();
      parentSplitter->insertWidget (index, currentSplitter->widget (0));
      if (qVersion() == QLatin1String("4.6.2")) currentSplitter->hide(); // bug in Qt v4.6.2, prevents crash (bug:232140), line can be removed once we are sure that noone uses Qt 4.6.2 anymore.
      delete currentSplitter;
      // now restore the sizes again
      parentSplitter->setSizes(parentSizes);
    }
  }
  else if( QSplitter* splitter = qobject_cast<QSplitter*>(currentSplitter->widget(0)) )
  {
    // we are the root splitter and have only one child, which is also a splitter
    // -> eliminate the redundant splitter and move both children into the root splitter
    QList<int> sizes = splitter->sizes();
    // adapt splitter orientation to the splitter we are about to delete
    currentSplitter->setOrientation(splitter->orientation());
    currentSplitter->addWidget( splitter->widget(0) );
    currentSplitter->addWidget( splitter->widget(0) );
    delete splitter;
    currentSplitter->setSizes( sizes );
  }

  // find the view that is now active.
  KTextEditor::View* v = activeViewSpace()->currentView();
  if ( v )
    activateView( v );

  updateViewSpaceActions ();

  emit viewChanged();
}