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

void GLShaderDev::initializeDockWidgets()
{
    QSplitter*  splitter = new QSplitter;
    QTabWidget* optionTab = new QTabWidget;

    _shaderStages = new ShaderStagesView;
    _shaderInput = new ShaderInputView;

    optionTab->setMovable(true);
    optionTab->addTab(_shaderInput, tr("Shader Input"));
    optionTab->addTab(_shaderStages, tr("Build Stages"));

    splitter->setOrientation(Qt::Vertical);
    splitter->addWidget(_glpreview);
    splitter->addWidget(optionTab);

    QDockWidget *dockWidget = new QDockWidget(tr("OpenGL View"), this);
    dockWidget->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
    dockWidget->setWidget(splitter);
    addDockWidget(Qt::RightDockWidgetArea, dockWidget);
    //   dockWidget->setFloating(true); FIXME

    _buildOutputDock = new QDockWidget(tr("Build log"), this);
    _buildOutputDock->setAllowedAreas(Qt::BottomDockWidgetArea);
    _buildOutputDock->setFeatures(QDockWidget::DockWidgetVerticalTitleBar | _buildOutputDock->features());
    _buildOutputDock->setWidget(_output);
    addDockWidget(Qt::BottomDockWidgetArea, _buildOutputDock);
    _buildOutputDock->hide();

    connect(_output, SIGNAL(dereferencableItemActivated(const QString&, int, int)), _editor, SLOT(gotoFile(const QString&, int, int)));
}

logDirBrowser::logDirBrowser(QString path, QWidget *parent)
    : QWidget(parent)
{
	ui.setupUi(this);
	this->setWindowTitle(QString("Log Viewer :: Directory Browser [") + path + QString("]"));
	this->doc = new QTextDocument();
	this->dirModel = new QDirModel();
	QSplitter* split = new QSplitter();
	this->tree = new QTreeView(split);
	this->texte = new QTextEdit(split);
	this->tree->setSortingEnabled(true);
	this->tree->setModel(this->dirModel);
	this->tree->setRootIndex(this->dirModel->index(path));
	for (int c = 0; c < this->dirModel->columnCount(); ++c) {
		this->tree->resizeColumnToContents(c);
	}
	split->setOrientation(Qt::Vertical);

	this->texte->setReadOnly(true);

	connect(this->tree,SIGNAL(expanded(const QModelIndex &)),this,SLOT(slot_viewItem(const QModelIndex &)));

	this->layout()->addWidget(split);

}

void FenPrincipale::createDockWindows()
{
    QDockWidget *dockDonnee = new QDockWidget(tr("Données"), this);
    dockDonnee->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);

    addDockWidget(Qt::RightDockWidgetArea, dockDonnee);
   QSplitter *splitter = new QSplitter(dockDonnee);
   QSize size(800,800);
   splitter->setMinimumSize(size);
   splitter->addWidget(tablemesures);
   splitter->addWidget(tabless);
   splitter->setOrientation(Qt::Vertical);
   QList<int> list = QList<int>() << 800 << 800;

   splitter->setSizes(list);


    viewMenu->addAction(dockDonnee->toggleViewAction());

   QDockWidget *dockCalcul = new QDockWidget(tr("Calculs"), this);


    addDockWidget(Qt::RightDockWidgetArea, dockCalcul);
    viewMenu->addAction(dockCalcul->toggleViewAction());
   // QSplitter *splitter = new QSplitter(dockDonnee);

   //   splitter->addWidget(tabless);
    //  splitter->addWidget(tablemesures);
   //  QList<int> list = QList<int>() << 150 << 150;


//      splitter->setSizes(list);

  }

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);
            }
        }
    }
}

		main_window()
		{
			
			QWidget * top = new QWidget(this);	
			m_layout = new QGridLayout(top);
			setCentralWidget(top);
			
			m_first = new draw_widget(top);
			m_second = new draw_widget(top);
			m_third = new draw_widget(top);
			
			m_top_splitter = new QSplitter(top);
			m_top_splitter->addWidget(m_first);
			
			QSplitter * other = new QSplitter(top);
			other->addWidget(m_second);
		
			
			QSplitter * another = new QSplitter(top);
			another->addWidget(m_third);
			another->setOrientation(Qt::Horizontal);
			
			
			m_layout->addWidget(m_top_splitter,0,0);
			m_layout->addWidget(other,1,0,1,2);
			m_layout->addWidget(another,0,1);
			
		}

StatisticsDock::StatisticsDock(QWidget *parent) :
    QDockWidget(parent)
{
    setWindowTitle(tr("Statistics"));
    QSplitter * mainSplitter = new QSplitter(this);
    mainSplitter->setOrientation(Qt::Vertical);

    QLabel * bootedUpTimeTextLabel = new QLabel("Booted up:",this);
    bootedUpTimeLabel = new QLabel("not available",this);

    QLabel * appRunningTimeTextLabel = new QLabel("Running for:",this);
    appRunningTimeLabel= new QLabel("0 s",this);

    QLabel * lastUpdateTextLabel = new QLabel("Last update:",this);
    lastUpdateLabel= new QLabel(QDateTime::currentDateTime().toString("hh:mm:ss"),this);

    mainSplitter->addWidget(bootedUpTimeTextLabel);
    mainSplitter->addWidget(bootedUpTimeLabel);

    mainSplitter->addWidget(appRunningTimeTextLabel);
    mainSplitter->addWidget(appRunningTimeLabel);


    mainSplitter->addWidget(lastUpdateTextLabel);
    mainSplitter->addWidget(lastUpdateLabel);
    mainSplitter->addWidget(new QWidget());

    setWidget(mainSplitter);

    QTimer *timer = new QTimer(this);
    connect(timer, SIGNAL(timeout()), this, SLOT(updateStatistics()));
    timer->start(iUpdateMs);
    elapsedTime = new QElapsedTimer();
    elapsedTime->start();
}

    QueryWidget::QueryWidget(IServerSPtr server, QWidget* parent)
        : QWidget(parent)
    {
        shellWidget_ = new BaseShellWidget(server);
        outputWidget_ = new OutputWidget(server);

        VERIFY(connect(shellWidget_, &BaseShellWidget::rootCreated, outputWidget_, &OutputWidget::rootCreate));
        VERIFY(connect(shellWidget_, &BaseShellWidget::rootCompleated, outputWidget_, &OutputWidget::rootCompleate));

        VERIFY(connect(shellWidget_, &BaseShellWidget::addedChild, outputWidget_, &OutputWidget::addChild));
        VERIFY(connect(shellWidget_, &BaseShellWidget::itemUpdated, outputWidget_, &OutputWidget::itemUpdate));

        QSplitter* splitter = new QSplitter;
#ifdef OS_WIN
        splitter->setStyleSheet("QSplitter::handle { background-color: gray }");
#endif
        splitter->setOrientation(Qt::Vertical);
        splitter->setHandleWidth(1);

        QVBoxLayout *mainLayout = new QVBoxLayout;
        splitter->addWidget(shellWidget_);
        splitter->addWidget(outputWidget_);
        splitter->setStretchFactor(0, 0);
        splitter->setStretchFactor(1, 1);
        mainLayout->addWidget(splitter);
        setMinimumSize(QSize(min_width, min_height));

        setLayout(mainLayout);
    }

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);
    }
}

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 ();
}

QWidget* MainWindow::createRightView()
{
	QSplitter* splitter = new QSplitter;
	splitter->setOrientation(Qt::Vertical);
	splitter->addWidget(new QTreeView);
	splitter->addWidget(new QTreeView);
	return splitter;
}

MultiWindowVisApp::MultiWindowVisApp(VisItViewer *v) : QMainWindow()
{
    viewer = v;
    windowsAdded = false;
    currentWindow = 0;
    for(int i = 0; i < NWINDOWS + 1; ++i)
        viswindows[i] = 0;

    setWindowTitle(tr("Multiwindow visualization"));

    // Create the window.
    QWidget *central = new QWidget(this);
    setCentralWidget(central);

    QHBoxLayout *hLayout = new QHBoxLayout(central);
    hLayout->setMargin(10);
    hLayout->setSpacing(10);
    QVBoxLayout *leftLayout = new QVBoxLayout(0);
    leftLayout->setSpacing(10);
    hLayout->addLayout(leftLayout);

    QLabel *scalarLabel = new QLabel(tr("Scalar variables"), central);
    leftLayout->addWidget(scalarLabel);

    variables = new QListWidget(central);
    leftLayout->addWidget(variables);
    connect(variables, SIGNAL(currentTextChanged(const QString &)),
            this, SLOT(onSelectVariable(const QString &)));

    // Create the visualization windows. Do an easy layout in this example.
    QSplitter *splitter = new QSplitter(central);
    splitter->setOrientation(Qt::Horizontal);
    hLayout->addWidget(splitter, 100);

    viswindows[PSEUDOCOLOR_WINDOW] = new vtkQtRenderWindow(splitter);
    viswindows[PSEUDOCOLOR_WINDOW]->setMinimumSize(QSize(300,400));

    viswindows[VOLUME_WINDOW] = new vtkQtRenderWindow(splitter);
    viswindows[VOLUME_WINDOW]->setMinimumSize(QSize(300,400));
 
    //
    // Register a window creation function (before Setup) that will
    // return the vtkQtRenderWindow objects that we've already
    // parented into our interface.
    //
    viewer->SetWindowCreationCallback(ReturnVisWin, (void *)this);

    // Create menus
    QMenu *fileMenu = menuBar()->addMenu(tr("File"));
    fileMenu->addAction(tr("Open . . ."), this, SLOT(selectFile()));
    fileMenu->addSeparator();
    fileMenu->addAction(tr("Quit"), qApp, SLOT(quit()));

    QMenu *controlsMenu = menuBar()->addMenu(tr("Controls"));
    controlsMenu->addAction(tr("Open GUI"), this, SLOT(openGUI()));
}

EncodeDecodeDialog::EncodeDecodeDialog(QWidget* parent)
    : QDialog(parent)
{
    setWindowIcon(GuiFactory::instance().encodeDecodeIcon());

    setWindowTitle(translations::trEncodeDecode);
    setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
    QVBoxLayout* layout = new QVBoxLayout;

    QDialogButtonBox* buttonBox = new QDialogButtonBox(QDialogButtonBox::Close);
    QPushButton* closeButton = buttonBox->button(QDialogButtonBox::Close);
    buttonBox->addButton(closeButton, QDialogButtonBox::ButtonRole(QDialogButtonBox::RejectRole | QDialogButtonBox::AcceptRole));
    VERIFY(connect(buttonBox, &QDialogButtonBox::rejected, this, &EncodeDecodeDialog::reject));

    QToolButton* decode = new QToolButton;
    decode->setIcon(GuiFactory::instance().executeIcon());
    VERIFY(connect(decode, &QToolButton::clicked, this, &EncodeDecodeDialog::decode));

    decoders_ = new QComboBox;
    for(int i = 0; i < SIZEOFMASS(common::EDecoderTypes); ++i) {
        decoders_->addItem(common::convertFromString<QString>(common::EDecoderTypes[i]));
    }

    QHBoxLayout* toolBarLayout = new QHBoxLayout;
    toolBarLayout->setContentsMargins(0, 0, 0, 0);
    toolBarLayout->addWidget(decode);
    toolBarLayout->addWidget(decoders_);

    encodeButton_ = new QRadioButton;
    decodeButton_ = new QRadioButton;
    toolBarLayout->addWidget(encodeButton_);
    toolBarLayout->addWidget(decodeButton_);

    QSplitter* splitter = new QSplitter;
    splitter->setOrientation(Qt::Horizontal);
    splitter->setHandleWidth(1);
    splitter->setContentsMargins(0, 0, 0, 0);
    toolBarLayout->addWidget(splitter);

    input_ = new FastoEditor;
    input_->installEventFilter(this);
    output_ = new FastoEditor;
    output_->installEventFilter(this);

    layout->addWidget(input_);
    layout->addLayout(toolBarLayout);
    layout->addWidget(output_);
    layout->addWidget(buttonBox);

    setMinimumSize(QSize(width, height));
    setLayout(layout);

    retranslateUi();
}

CentralWidget::CentralWidget(QWidget *parent) : QWidget(parent), timeOut(DEFAULT_TIMEOUT)
{

    watcher = new QFutureWatcher<QSharedPointer<PatternViewMap>>();
    compiler = new PatternCompiler();
    txt = new TextBasicWidget(this);
    pattern = new PatternsBasicWidget(compiler,this);
    matches = new MatchesBasicWidget(this);
    timeoutTimer = new QTimer(this);
    timeoutTimer->setSingleShot(true);
    QSplitter* vert = new QSplitter();
    QSplitter* horiz = new QSplitter();
    QWidget* containter = new QWidget();
    QHBoxLayout* containterLay = new QHBoxLayout();
    QVBoxLayout* mainLay = new QVBoxLayout();
    containterLay->setContentsMargins(0,0,0,0);
    horiz->addWidget(txt);
    horiz->addWidget(pattern);
    containterLay->addWidget(horiz);
    containter->setLayout(containterLay);
    vert->setOrientation(Qt::Vertical);
    vert->addWidget(containter);
    vert->addWidget(matches);

//    vert->addWidget(progress);
    mainLay->addWidget(vert);
    setLayout(mainLay);
    connect(pattern,SIGNAL(matchClicked()), this,SLOT(slotAnalyze()));
    connect(matches,SIGNAL(patternWasUnchecked(QString)),txt,SLOT(slotPatternUncheked(QString)));
    connect(matches,SIGNAL(patternWasChecked(QString)),txt,SLOT(slotPatternChecked(QString)));
    connect(matches,SIGNAL(showAll()),txt,SLOT(slotHighlightAll()));
    connect(matches,SIGNAL(showAll()),pattern,SLOT(slotDisableMatch()));
    connect(matches,SIGNAL(hideAll()),txt,SLOT(slotDehighlightAll()));
    connect(matches,SIGNAL(rowClicked(int,int)),txt,SLOT(slotSelectFragment(int,int)));
    connect(matches,SIGNAL(patternWasUnchecked(QString)),this,SIGNAL(statusHighlighting()));
    connect(matches,SIGNAL(patternWasChecked(QString)),this,SIGNAL(statusHighlighting()));

    connect(txt,SIGNAL(tabChanged(int)),matches,SLOT(slotChangeTab(int)));
    connect(txt,SIGNAL(tabClosed(int)),matches,SLOT(slotCloseTab(int)));
    connect(txt,SIGNAL(editEnabled()),matches,SLOT(slotClear()));
    connect(txt,SIGNAL(editEnabled()),this,SLOT(slotEdit()));
    connect(txt,SIGNAL(checkingEnabled()),matches,SLOT(slotEnableChecking()));
    connect(txt,SIGNAL(checkingEnabled()),this,SIGNAL(statusReady()));
    connect(txt, SIGNAL(checkingEnabled()),pattern, SLOT(slotEnableMatch()));

    connect(watcher,SIGNAL(finished()),this,SLOT(slotDisplay()));
    connect(timeoutTimer,SIGNAL(timeout()),this,SLOT(slotTimeout()));

    //connect(watcher,SIGNAL(progressValueChanged(int)),this,SLOT(slotProgress(int)));
    if (QFile::exists(CRASH_TEXT) && QFile::exists(CRASH_PATTERNS)){
        loadAfterCrash(CRASH_TEXT, CRASH_PATTERNS);
    }
}

void PersonalMessageWidget::initialize() {
	setWindowTitle("Trek Personal Chat");
//	QFont f = mUsernameLabel.font();
//	f.setPointSize(11);
//	mUsernameLabel.setFont(f);
	
	mSendButton.setText("Send");
	mSendButton.setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Expanding);

	mConversationText.setReadOnly(true);

	mInputText.installEventFilter(this);

	QHBoxLayout* inputLayout = new QHBoxLayout();
	QWidget* inputWidget = new QWidget();
	inputLayout->addWidget(&mInputText);
	inputLayout->addWidget(&mSendButton);
	inputWidget->setLayout(inputLayout);
	QSplitter* splitter = new QSplitter();
	splitter->setOrientation(Qt::Vertical);
	splitter->addWidget(&mConversationText);
	splitter->addWidget(inputWidget);
	splitter->setCollapsible(0,false);
	splitter->setCollapsible(1,false);
	splitter->setHandleWidth(15);

	mToolbar.setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Preferred);
	mSaveAction = mToolbar.addAction("Save");
	mClearAction = mToolbar.addAction("Clear");

	mGMainLayout.addWidget(&mUserIconLabel,0,2,2,1,Qt::AlignRight);
	mGMainLayout.addWidget(&mToolbar, 1,0,1,2); //,1,2);
	mGMainLayout.addWidget(&mUsernameLabel,0,0,Qt::AlignLeft);
	mGMainLayout.addWidget(splitter, 2,0,1,3);

	setLayout(&mGMainLayout);

	QList<int> sizes;
	sizes.append(400);
	sizes.append(100);
	splitter->setSizes(sizes);

	userDataAltered();
	connect(mClearAction, SIGNAL(triggered()), &mConversationText, SLOT(clear()));
	connect(mSaveAction, SIGNAL(triggered()), this, SLOT(save())); 
	connect(&mSendButton, SIGNAL(clicked()), this, SLOT(send()));
	connect(mUserData, SIGNAL(dataAltered()), this, SLOT(userDataAltered()));
	connect(this, SIGNAL(controller_serverPersonalSpeak(const QUuid&, const QString&)), Controller::self(), SIGNAL(serverPersonalSpeak(const QUuid&, const QString&)));
	connect(Controller::self(), SIGNAL(personalCommuniqueReceived(const QUuid&, const QString&)), this, SLOT(controller_personalCommuniqueReceived(const QUuid&, const QString&)));


}

    ServerHistoryDialog::ServerHistoryDialog(const QString& title, connectionTypes type, QWidget* parent)
        : QDialog(parent, Qt::WindowMinMaxButtonsHint | Qt::WindowCloseButtonHint ), type_(type)
    {
        using namespace translations;

        setWindowIcon(GuiFactory::instance().icon(type_));
        setWindowTitle(title);

        graphWidget_ = new fasto::qt::gui::GraphWidget;
        settingsGraph_ = new QWidget;
        QHBoxLayout *mainL = new QHBoxLayout;

        QSplitter *splitter = new QSplitter;
        splitter->setOrientation(Qt::Horizontal);
        splitter->setHandleWidth(1);
        splitter->setContentsMargins(0, 0, 0, 0);

        mainL->addWidget(splitter);
        splitter->addWidget(settingsGraph_);

        serverInfoGroupsNames_ = new QComboBox;
        serverInfoFields_ = new QComboBox;

        typedef void (QComboBox::*curc)(int);
        VERIFY(connect(serverInfoGroupsNames_, static_cast<curc>(&QComboBox::currentIndexChanged), this, &ServerHistoryDialog::refreshInfoFields ));
        VERIFY(connect(serverInfoFields_, static_cast<curc>(&QComboBox::currentIndexChanged), this, &ServerHistoryDialog::refreshGraph ));
        if(type_ == REDIS){
            for(int i = 0; i < redisHeaders.size(); ++i){
                serverInfoGroupsNames_->addItem(common::convertFromString<QString>(redisHeaders[i]));
            }
        }
        else if(type_ == MEMCACHED){
            for(int i = 0; i < memcachedHeaders.size(); ++i){
                serverInfoGroupsNames_->addItem(common::convertFromString<QString>(memcachedHeaders[i]));
            }
        }
        else if(type_ == SSDB){
            for(int i = 0; i < SsdbHeaders.size(); ++i){
                serverInfoGroupsNames_->addItem(common::convertFromString<QString>(SsdbHeaders[i]));
            }
        }

        QVBoxLayout *setingsLayout = new QVBoxLayout;
        setingsLayout->addWidget(serverInfoGroupsNames_);
        setingsLayout->addWidget(serverInfoFields_);
        settingsGraph_->setLayout(setingsLayout);

        splitter->addWidget(graphWidget_);
        setLayout(mainL);

        glassWidget_ = new fasto::qt::gui::GlassWidget(GuiFactory::instance().pathToLoadingGif(), trLoading, 0.5, QColor(111, 111, 100), this);
    }