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

//!
//! Splits the panel frame according to the given orientation.
//!
//! \param orientation The orientation in which to split the panel frame.
//!
void PanelFrame::split ( Qt::Orientation orientation )
{
    QMainWindow *mainWindow = qobject_cast<QMainWindow *>(parentWidget());
    QSplitter *parentSplitter = qobject_cast<QSplitter *>(parentWidget());
	parentSplitter->setHandleWidth(1);
    if (!parentSplitter && !mainWindow) {
        QMessageBox::information(this, "Split Panel", "Splitting this panel is not possible.");
        return;
    }

    // flip the orientation
    if (orientation == Qt::Horizontal)
        orientation = Qt::Vertical;
    else
        orientation = Qt::Horizontal;

    // save the size of this panel
    QSize panelSize = size();
    int widthHeight = orientation == Qt::Horizontal ? panelSize.width() : panelSize.height();
    // clone this panel frame
    PanelFrame *clonedPanelFrame = new PanelFrame(m_panelType, parentWidget(), windowFlags());

    QList<int> sizes;
    int panelIndex;
    if (parentSplitter) {
        // save the parent splitter's sizes
        sizes = parentSplitter->sizes();
        // obtain the index of this panel in its parent splitter
        panelIndex = parentSplitter->indexOf(this);
    }

    // create new splitter for this panel and its clone
    QSplitter *newSplitter = new QSplitter(orientation);
	newSplitter->setHandleWidth(1);
    newSplitter->addWidget(this);
    newSplitter->addWidget(clonedPanelFrame);
    // give both panels in the new splitter the same space
    QList<int> newSizes;
    newSizes << widthHeight / 2 << widthHeight / 2;
    newSplitter->setSizes(newSizes);

    if (parentSplitter) {
        // insert the new splitter into the panel's former parent splitter
        parentSplitter->insertWidget(panelIndex, newSplitter);
        // restore the parent splitter's sizes
        parentSplitter->setSizes(sizes);
    } else {
        mainWindow->setCentralWidget(newSplitter);
    }
}

//!
//! Maximizes the given widget inside its parent widget.
//!
//! The widget can be a panel frame or a splitter widget.
//!
//! \param widget The widget to maximize.
//!
void PanelFrame::maximizeWidget ( QWidget *widget )
{
    QWidget *parentWidget = widget->parentWidget();
    QSplitter *parentSplitter = qobject_cast<QSplitter *>(parentWidget);
	parentSplitter->setHandleWidth(1);
    if (!parentSplitter) {
        QMessageBox::information(this, "Maximize Panel", "The panel is already maximized.");
        return;
    }

    int index = parentSplitter->indexOf(widget);
    QList<int> sizes = parentSplitter->sizes();

    // count number of visible panel frames
    int visiblePanelFrames = 0;
    for (int i = 0; i < sizes.size(); ++i)
        if (sizes[i] > 0)
            ++visiblePanelFrames;

    if (visiblePanelFrames == 1)
        maximizeWidget(parentSplitter);
    else {
        // hide all other panels in the same splitter
        for (int i = 0; i < sizes.size(); ++i)
            if (i != index)
                sizes[i] = 0;
        parentSplitter->setSizes(sizes);
    }
}

//!
//! Minimizes the given widget inside its parent widget.
//!
//! The widget can be a panel frame or a splitter widget.
//!
//! \param widget The widget to minimize.
//!
void PanelFrame::minimizeWidget ( QWidget *widget )
{
    QWidget *parentWidget = widget->parentWidget();
    QSplitter *parentSplitter = qobject_cast<QSplitter *>(parentWidget);
	parentSplitter->setHandleWidth(1);
    if (!parentSplitter) {
        QMessageBox::information(this, "Minimize Panel", "The last visible panel cannot be minimized.");
        return;
    }

    int index = parentSplitter->indexOf(widget);
    QList<int> sizes = parentSplitter->sizes();

    // count number of visible panel frames
    int visiblePanelFrames = 0;
    for (int i = 0; i < sizes.size(); ++i)
        if (sizes[i] > 0)
            ++visiblePanelFrames;

    if (visiblePanelFrames == 1)
        minimizeWidget(parentSplitter);
    else {
        sizes[index] = 0;
        parentSplitter->setSizes(sizes);
    }
}

MainWindow::MainWindow(FilesList *filesList)
{
    this->filesList = filesList;

    player = new Player(this);
    filesListWidget = new FilesListWidget(this->filesList, this);
    filesCountLabel = new QLabel(FILES_COUNT_TEXT.arg(0), this);

    QSplitter *splitter = new QSplitter(Qt::Vertical, this);
    //splitter->setStyleSheet("QSplitter::handle {background-color: black;}");

    splitter->addWidget(initVideoFrame());
    splitter->addWidget(initControlFrame());
    splitter->setChildrenCollapsible(false);
    //splitter->setCursor(Qt::SizeVerCursor);
    splitter->setHandleWidth(10);

    initMenu();
    setCentralWidget(splitter);
    setWindowTitle("Visual Renamer");
    setWindowIcon(QIcon(":/resources/logo_small.png"));
    resize(850, 650);

    connect(filesListWidget, SIGNAL(fileSelected(int)), SLOT(fileSelected(int)));
    connect(this->filesList, SIGNAL(renamed(int,int)), SLOT(filesRenamed(int,int)));
    connect(this->filesList, &FilesList::reseted, this, [=](){fileSelected(-1); filesCountLabel->setText(FILES_COUNT_TEXT.arg(this->filesList->getSize()));});
    connect(this->filesList, &FilesList::filesAdded, this, [=](){filesCountLabel->setText(FILES_COUNT_TEXT.arg(this->filesList->getSize()));});
    connect(this->filesList, &FilesList::removed, this, [=](){fileSelected(-1); filesCountLabel->setText(FILES_COUNT_TEXT.arg(this->filesList->getSize()));});

    this->setFocus();
}

    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 SM_DriveEngine::reset(void)
{
    QHBoxLayout *hBoxLayout = new QHBoxLayout(SUi::inst()->panelsWidget);
    QSplitter *hSplitter = new QSplitter(Qt::Horizontal, SUi::inst()->panelsWidget);

    filesViews[ELeft] = new SM_FilePanel(ELeft);
    filesViews[ERight] = new SM_FilePanel(ERight);

    hBoxLayout->setContentsMargins(0, 0, 0, 0);
    hBoxLayout->addWidget(hSplitter);

    hSplitter->setHandleWidth(1);

    hSplitter->addWidget(filesViews[ELeft]);
    hSplitter->addWidget(filesViews[ERight]);

    for(int i = 0; i < EPanelsCount; ++i)
    {
        contentMngr[i].reset(new SM_ContentManager);
        contentMngr[i]->init();
    }

    checkUI.reset(new SM_CheckUI);
    filesTransferUI.reset(new SM_FilesTransferUI);
    filesUI.reset(new SM_ContentUI);

    connect(filesViews[ELeft], SIGNAL(signalAccountChanged(int, const QString&)), SLOT(slotAccountChanged(int, const QString&)));
    connect(filesViews[ERight], SIGNAL(signalAccountChanged(int, const QString&)), SLOT(slotAccountChanged(int, const QString&)));
}

dtkComposerNodeFactoryView::dtkComposerNodeFactoryView(QWidget *parent) : QWidget(parent), d(new dtkComposerNodeFactoryViewPrivate)
{
    d->factory = NULL;

    d->scope = new dtkWidgetsTagCloudScope(this);
    d->scope->toggle();

    d->cloud = new dtkWidgetsTagCloud(this);
    d->cloud->setSortingType(dtkWidgetsTagCloud::Alpha);
    d->cloud->setSortingOrder(dtkWidgetsTagCloud::Asc);
    d->cloud->setFontSize(17);
    d->cloud->setFontRange(15);

    d->view = new dtkWidgetsTagCloudView(this);

    d->controller = new dtkWidgetsTagCloudController;
    d->controller->attach(d->scope);
    d->controller->attach(d->view);
    d->controller->attach(d->cloud);
    d->controller->onUnionMode(false);

    QSplitter *splitter = new QSplitter(this);
    splitter->addWidget(d->cloud);
    splitter->addWidget(d->view);
    splitter->setOrientation(Qt::Vertical);
    splitter->setHandleWidth(1);

    QVBoxLayout *layout = new QVBoxLayout(this);
    layout->setContentsMargins(0, 0, 0, 0);
    layout->setSpacing(0);
    layout->addWidget(d->scope);
    layout->addWidget(splitter);

    this->addNote();
}

void IrcClient::createLayout()
{
    setWindowTitle(tr("Communi %1 example client").arg(IRC_VERSION_STR));

    // a read-only text editor for showing the messages
    textEdit = new QTextEdit(this);
    textEdit->setReadOnly(true);

    // a line editor for entering commands
    lineEdit = new QLineEdit(this);
    lineEdit->setAttribute(Qt::WA_MacShowFocusRect, false);
    textEdit->setFocusProxy(lineEdit);
    connect(lineEdit, SIGNAL(returnPressed()), this, SLOT(onTextEntered()));
    connect(lineEdit, SIGNAL(textEdited(QString)), this, SLOT(onTextEdited()));

    // the rest is just setting up the UI layout...
    QSplitter* splitter = new QSplitter(this);
    splitter->setHandleWidth(1);
    splitter->addWidget(textEdit);
    splitter->addWidget(userList);
    splitter->setStretchFactor(0, 5);
    splitter->setStretchFactor(1, 1);

    QWidget* container = new QWidget(this);
    QVBoxLayout* layout = new QVBoxLayout(container);
    layout->setSpacing(0);
    layout->setMargin(0);
    layout->addWidget(splitter);
    layout->addWidget(lineEdit);

    addWidget(container);

    setHandleWidth(1);
}

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

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

QSplitter* PaneSubWidget::createSplitter(QWidget* A,QWidget* B,QWidget* parent,bool vertical){
    QSplitter *split = new QSplitter(parent);
    split->setChildrenCollapsible(false);
    split->setHandleWidth(10);
    A->setParent(split);
    B->setParent(split);

    split->addWidget(A);    // add new widget "left of old"
    split->addWidget(B);      // add old widget
    B->show();
    A->show();
    return split;
}

//-----------------------------------------------------------------------------
// Function: AddressSpaceEditor::setupLayout()
//-----------------------------------------------------------------------------
void AddressSpaceEditor::setupLayout()
{
    QScrollArea* scrollArea = new QScrollArea(this);
    scrollArea->setWidgetResizable(true);
    scrollArea->setFrameShape(QFrame::NoFrame);

    QVBoxLayout* scrollLayout = new QVBoxLayout(this);
    scrollLayout->addWidget(scrollArea);
    scrollLayout->setContentsMargins(0, 0, 0, 0);

    QWidget* topWidget = new QWidget(scrollArea);
    topWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);

    QVBoxLayout* topLayout = new QVBoxLayout(topWidget);
    
    QHBoxLayout* nameAndGeneralLayout = new QHBoxLayout();
    nameAndGeneralLayout->addWidget(&nameEditor_, 0, Qt::AlignTop);
    nameAndGeneralLayout->addWidget(&generalEditor_);
    topLayout->addLayout(nameAndGeneralLayout);
    topLayout->addWidget(&segmentsEditor_, 1);
    topLayout->setContentsMargins(0, 0, 0, 0);

    QWidget* bottomWidget = new QWidget(scrollArea);
    bottomWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);

    QVBoxLayout* bottomLayout = new QVBoxLayout(bottomWidget);
    bottomLayout->addWidget(&localMemMapEditor_);
    bottomLayout->setContentsMargins(0, 0, 0, 0);

    QSplitter* verticalSplitter = new QSplitter(Qt::Vertical, scrollArea);
    verticalSplitter->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    verticalSplitter->addWidget(topWidget);
    verticalSplitter->addWidget(bottomWidget);
    verticalSplitter->setStretchFactor(1, 1);

    QSplitterHandle* handle = verticalSplitter->handle(1);
    QVBoxLayout* handleLayout = new QVBoxLayout(handle);
    handleLayout->setSpacing(0);
    handleLayout->setMargin(0);

    QFrame* line = new QFrame(handle);
    line->setLineWidth(2);
    line->setMidLineWidth(2);
    line->setFrameShape(QFrame::HLine);
    line->setFrameShadow(QFrame::Sunken);
    handleLayout->addWidget(line);

    verticalSplitter->setHandleWidth(10);

    scrollArea->setWidget(verticalSplitter);
}

    OutputWidget::OutputWidget(IServerSPtr server, QWidget* parent)
        : QWidget(parent)
    {
        commonModel_ = new FastoCommonModel(this);
        VERIFY(connect(commonModel_, &FastoCommonModel::changedValue, server.get(), &IServer::changeValue, Qt::DirectConnection));
        VERIFY(connect(server.get(), &IServer::startedChangeDbValue, this, &OutputWidget::startChangeDbValue, Qt::DirectConnection));
        VERIFY(connect(server.get(), &IServer::finishedChangeDbValue, this, &OutputWidget::finishChangeDbValue, Qt::DirectConnection));

        treeView_ = new FastoTreeView;
        treeView_->setModel(commonModel_);

        tableView_ = new FastoTableView;
        tableView_->setModel(commonModel_);

        textView_ = new FastoTextView(server->outputDelemitr());
        textView_->setModel(commonModel_);
        textView_->setReadOnly(true);

        timeLabel_ = new fasto::qt::gui::IconLabel(GuiFactory::instance().timeIcon(), "0", QSize(32, 32));

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

        treeButton_ = new QPushButton;
        tableButton_ = new QPushButton;
        textButton_ = new QPushButton;
        treeButton_->setIcon(GuiFactory::instance().treeIcon());
        VERIFY(connect(treeButton_, SIGNAL(clicked()), this, SLOT(setTreeView())));
        tableButton_->setIcon(GuiFactory::instance().tableIcon());
        VERIFY(connect(tableButton_, SIGNAL(clicked()), this, SLOT(setTableView())));
        textButton_->setIcon(GuiFactory::instance().textIcon());
        VERIFY(connect(textButton_, SIGNAL(clicked()), this, SLOT(setTextView())));

        topL->addWidget(treeButton_);
        topL->addWidget(tableButton_);
        topL->addWidget(textButton_);
        topL->addWidget(splitter);
        topL->addWidget(timeLabel_);

        mainL->addLayout(topL);
        mainL->addWidget(treeView_);
        mainL->addWidget(tableView_);
        mainL->addWidget(textView_);
        setLayout(mainL);
        syncWithSettings();
    }

    ServerHistoryDialog::ServerHistoryDialog(IServerSPtr server, QWidget* parent)
        : QDialog(parent, Qt::WindowMinMaxButtonsHint | Qt::WindowCloseButtonHint ), server_(server)
    {
        using namespace translations;
        CHECK(server_);

        setWindowIcon(GuiFactory::instance().icon(server_->type()));

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

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

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

        clearHistory_ = new QPushButton;
        VERIFY(connect(clearHistory_, &QPushButton::clicked, this, &ServerHistoryDialog::clearHistory));
        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 ));

        const std::vector<std::string> headers = infoHeadersFromType(server_->type());
        for(int i = 0; i < headers.size(); ++i){
            serverInfoGroupsNames_->addItem(common::convertFromString<QString>(headers[i]));
        }
        QVBoxLayout *setingsLayout = new QVBoxLayout;
        setingsLayout->addWidget(clearHistory_);
        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);
        VERIFY(connect(server.get(), &IServer::startedLoadServerHistoryInfo, this, &ServerHistoryDialog::startLoadServerHistoryInfo));
        VERIFY(connect(server.get(), &IServer::finishedLoadServerHistoryInfo, this, &ServerHistoryDialog::finishLoadServerHistoryInfo));
        VERIFY(connect(server.get(), &IServer::startedClearServerHistory, this, &ServerHistoryDialog::startClearServerHistory));
        VERIFY(connect(server.get(), &IServer::finishedClearServerHistory, this, &ServerHistoryDialog::finishClearServerHistory));
        VERIFY(connect(server.get(), &IServer::serverInfoSnapShoot, this, &ServerHistoryDialog::snapShotAdd));
        retranslateUi();
    }