bool TreeWidgetColumnStretcher::eventFilter(QObject *obj, QEvent *ev)
{
    if (obj == parent())
    {
        if (ev->type() == QEvent::Show)
        {
            QHeaderView *hv = qobject_cast<QHeaderView*>(obj);
            for (int i = 0; i < hv->count(); ++i)
				hv->setSectionResizeMode(i, QHeaderView::Interactive);
        }
        else if (ev->type() == QEvent::Hide)
        {
            QHeaderView *hv = qobject_cast<QHeaderView*>(obj);
            for (int i = 0; i < hv->count(); ++i)
				hv->setSectionResizeMode(i, i == m_columnToStretch ? QHeaderView::Stretch : QHeaderView::ResizeToContents);
        }
        else if (ev->type() == QEvent::Resize)
        {
            QHeaderView *hv = qobject_cast<QHeaderView*>(obj);
            if (hv->sectionResizeMode(m_columnToStretch) == QHeaderView::Interactive)
            {
                QResizeEvent *re = static_cast<QResizeEvent*>(ev);
                int diff = re->size().width() - re->oldSize().width() ;
                hv->resizeSection(m_columnToStretch, qMax(32, hv->sectionSize(1) + diff));
            }
        }
    }
    return false;
}
LinkPropertyViewImpl::LinkPropertyViewImpl(LinkPropertyView* self)
    : self(self)
{
    linkSelectionView = LinkSelectionView::mainInstance();
    
    setFrameShape(QFrame::NoFrame);
    setColumnCount(2);
    setSelectionBehavior(QAbstractItemView::SelectRows);
    setSelectionMode(QAbstractItemView::NoSelection);

    QHeaderView* hh = horizontalHeader();
    QHeaderView* vh = verticalHeader();
    hh->hide();
    vh->hide();
    hh->setSectionResizeMode(QHeaderView::Stretch);
    vh->setSectionResizeMode(QHeaderView::ResizeToContents);
    hh->setStretchLastSection(true);

    fontPointSizeDiff = 0;
    MappingPtr config = AppConfig::archive()->openMapping("LinkPropertyView");
    int storedFontPointSizeDiff;
    if(config->read("fontZoom", storedFontPointSizeDiff)){
        zoomFontSize(storedFontPointSizeDiff);
    }

    connections.add(
        BodyBar::instance()->sigCurrentBodyItemChanged().connect(
            std::bind(&LinkPropertyViewImpl::onCurrentBodyItemChanged, this, _1)));

    connections.add(
        linkSelectionView->sigSelectionChanged().connect(
            std::bind(&LinkPropertyViewImpl::updateProperties, this)));
}
ActivateModsDialog::ActivateModsDialog(const std::map<QString, std::vector<QString> > &missingPlugins, QWidget *parent)
  : TutorableDialog("ActivateMods", parent), ui(new Ui::ActivateModsDialog)
{
  ui->setupUi(this);

  QTableWidget *modsTable = findChild<QTableWidget*>("modsTable");
  QHeaderView *headerView = modsTable->horizontalHeader();
#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
  headerView->setSectionResizeMode(0, QHeaderView::Stretch);
  headerView->setSectionResizeMode(1, QHeaderView::Interactive);
#else
  headerView->setResizeMode(0, QHeaderView::Stretch);
  headerView->setResizeMode(1, QHeaderView::Interactive);
#endif

  int row = 0;

  modsTable->setRowCount(missingPlugins.size());

  for (std::map<QString, std::vector<QString> >::const_iterator espIter = missingPlugins.begin();
       espIter != missingPlugins.end(); ++espIter, ++row) {
    modsTable->setCellWidget(row, 0, new QLabel(espIter->first));
    if (espIter->second.size() == 0) {
      modsTable->setCellWidget(row, 1, new QLabel(tr("not found")));
    } else {
      QComboBox* combo = new QComboBox();
      for (std::vector<QString>::const_iterator modIter = espIter->second.begin();
           modIter != espIter->second.end(); ++modIter) {
        combo->addItem(*modIter);
      }
      modsTable->setCellWidget(row, 1, combo);
    }
  }
}
Exemple #4
0
void ListView::setupGeometry() {

	QPalette pl = palette();
	pl.setColor(QPalette::Base, ODD_LINE_COL);
	pl.setColor(QPalette::AlternateBase, EVEN_LINE_COL);
	setPalette(pl); // does not seem to inherit application paletteAnnotate

	QHeaderView* hv = header();
	hv->setStretchLastSection(true);
#if QT_VERSION < 0x050000
	hv->setResizeMode(LOG_COL, QHeaderView::Interactive);
	hv->setResizeMode(TIME_COL, QHeaderView::Interactive);
	hv->setResizeMode(ANN_ID_COL, QHeaderView::ResizeToContents);
#else
    hv->setSectionResizeMode(LOG_COL, QHeaderView::Interactive);
    hv->setSectionResizeMode(TIME_COL, QHeaderView::Interactive);
    hv->setSectionResizeMode(ANN_ID_COL, QHeaderView::ResizeToContents);
#endif
	hv->resizeSection(GRAPH_COL, DEF_GRAPH_COL_WIDTH);
	hv->resizeSection(LOG_COL, DEF_LOG_COL_WIDTH);
	hv->resizeSection(AUTH_COL, DEF_AUTH_COL_WIDTH);
	hv->resizeSection(TIME_COL, DEF_TIME_COL_WIDTH);

	if (git->isMainHistory(fh))
		hideColumn(ANN_ID_COL);
}
Exemple #5
0
VcsEventWidget::VcsEventWidget( const QUrl& url, const VcsRevision& rev, KDevelop::IBasicVersionControl* iface, QWidget* parent )
    : QWidget(parent), d(new VcsEventWidgetPrivate(this) )
{
    d->m_iface = iface;
    d->m_url = url;
    d->m_ui = new Ui::VcsEventWidget();
    d->m_ui->setupUi(this);

    d->m_logModel= new VcsEventModel(iface, rev, url, this);
    d->m_ui->eventView->setModel( d->m_logModel );
    d->m_ui->eventView->sortByColumn(0, Qt::DescendingOrder);
    d->m_ui->eventView->setContextMenuPolicy( Qt::CustomContextMenu );
    QHeaderView* header = d->m_ui->eventView->header();
    header->setSectionResizeMode( 0, QHeaderView::ResizeToContents );
    header->setSectionResizeMode( 1, QHeaderView::Stretch );
    header->setSectionResizeMode( 2, QHeaderView::ResizeToContents );
    header->setSectionResizeMode( 3, QHeaderView::ResizeToContents );

    d->m_detailModel = new VcsItemEventModel(this);
    d->m_ui->itemEventView->setModel( d->m_detailModel );

    connect( d->m_ui->eventView, &QTreeView::clicked,
             this, [&] (const QModelIndex& index) { d->eventViewClicked(index); } );
    connect( d->m_ui->eventView->selectionModel(), &QItemSelectionModel::currentRowChanged,
             this, [&] (const QModelIndex& start, const QModelIndex& end) { d->currentRowChanged(start, end); });
    connect( d->m_ui->eventView, &QTreeView::customContextMenuRequested,
             this, [&] (const QPoint& point) { d->eventViewCustomContextMenuRequested(point); } );
}
Exemple #6
0
void
ReplaceWidget::updateFromCurrentDevice( QComboBox* devicesComboBox )
{
    QModelIndex index = m_core->deviceModel()->index( devicesComboBox->currentIndex(), 0 );
    if ( !index.isValid() )
        return;

    Device* device = m_core->deviceModel()->deviceForIndex( index );

    QAbstractItemModel* oldModel = m_ui->partitionTreeView->model();
    if ( oldModel )
        disconnect( oldModel, 0, this, 0 );

    PartitionModel* model = m_core->partitionModelForDevice( device );
    m_ui->partitionTreeView->setModel( model );
    m_ui->partitionTreeView->expandAll();

    // Must be done here because we need to have a model set to define
    // individual column resize mode
    QHeaderView* header = m_ui->partitionTreeView->header();
    header->setSectionResizeMode( QHeaderView::ResizeToContents );
    header->setSectionResizeMode( 0, QHeaderView::Stretch );

    //updateButtons();
    // Establish connection here because selection model is destroyed when
    // model changes
    connect( m_ui->partitionTreeView->selectionModel(), &QItemSelectionModel::currentRowChanged,
             this, &ReplaceWidget::onPartitionViewActivated );

    connect( model, &QAbstractItemModel::modelReset, this, &ReplaceWidget::onPartitionModelReset );
}
EditBookmarksDialog::EditBookmarksDialog(IBookmarks *ABookmarks, const Jid &AStreamJid, const QList<IBookmark> &AList, QWidget *AParent) : QDialog(AParent)
{
	REPORT_VIEW;
	ui.setupUi(this);
	setAttribute(Qt::WA_DeleteOnClose,true);
	setWindowTitle(tr("Edit bookmarks - %1").arg(AStreamJid.uBare()));
	IconStorage::staticStorage(RSR_STORAGE_MENUICONS)->insertAutoIcon(this,MNI_BOOKMARKS_EDIT,0,0,"windowIcon");

	FBookmarks = ABookmarks;
	FStreamJid = AStreamJid;

	ui.tbwBookmarks->setRowCount(AList.count());
	for (int row=0; row<AList.count(); ++row)
	{
		IBookmark bookmark = AList.at(row);
		setBookmarkToRow(row,bookmark);
	}

	QHeaderView *header = ui.tbwBookmarks->horizontalHeader();
	header->setSectionsClickable(true);
	header->setSectionResizeMode(COL_NAME,QHeaderView::ResizeToContents);
	header->setSectionResizeMode(COL_VALUE,QHeaderView::Stretch);
	header->setSectionResizeMode(COL_NICK,QHeaderView::ResizeToContents);
	header->hideSection(COL_SORT);
	connect(header,SIGNAL(sectionClicked(int)),SLOT(onSortingStateChange(int)));

	connect(ui.pbtAdd,SIGNAL(clicked()),SLOT(onEditButtonClicked()));
	connect(ui.pbtEdit,SIGNAL(clicked()),SLOT(onEditButtonClicked()));
	connect(ui.pbtDelete,SIGNAL(clicked()),SLOT(onEditButtonClicked()));
	connect(ui.pbtMoveUp,SIGNAL(clicked()),SLOT(onEditButtonClicked()));
	connect(ui.pbtMoveDown,SIGNAL(clicked()),SLOT(onEditButtonClicked()));
	connect(ui.bbxButtons,SIGNAL(accepted()),SLOT(onDialogAccepted()));

	connect(ui.tbwBookmarks,SIGNAL(itemDoubleClicked(QTableWidgetItem *)),SLOT(onTableItemDoubleClicked(QTableWidgetItem *)));
}
QWidget *DebuggerOptionsPage::widget()
{
    if (!m_configWidget) {
        m_configWidget = new QWidget;

        m_addButton = new QPushButton(tr("Add"), m_configWidget);
        m_cloneButton = new QPushButton(tr("Clone"), m_configWidget);
        m_delButton = new QPushButton(tr("Remove"), m_configWidget);

        m_container = new DetailsWidget(m_configWidget);
        m_container->setState(DetailsWidget::NoSummary);
        m_container->setVisible(false);

        m_debuggerView = new QTreeView(m_configWidget);
        m_model = new DebuggerItemModel(m_debuggerView);
        m_debuggerView->setModel(m_model);
        m_debuggerView->setUniformRowHeights(true);
        m_debuggerView->setSelectionMode(QAbstractItemView::SingleSelection);
        m_debuggerView->setSelectionBehavior(QAbstractItemView::SelectRows);
        m_debuggerView->expandAll();

        QHeaderView *header = m_debuggerView->header();
        header->setStretchLastSection(false);
        header->setSectionResizeMode(0, QHeaderView::ResizeToContents);
        header->setSectionResizeMode(1, QHeaderView::ResizeToContents);
        header->setSectionResizeMode(2, QHeaderView::Stretch);

        QVBoxLayout *buttonLayout = new QVBoxLayout();
        buttonLayout->setSpacing(6);
        buttonLayout->setContentsMargins(0, 0, 0, 0);
        buttonLayout->addWidget(m_addButton);
        buttonLayout->addWidget(m_cloneButton);
        buttonLayout->addWidget(m_delButton);
        buttonLayout->addItem(new QSpacerItem(10, 40, QSizePolicy::Minimum, QSizePolicy::Expanding));

        QVBoxLayout *verticalLayout = new QVBoxLayout();
        verticalLayout->addWidget(m_debuggerView);
        verticalLayout->addWidget(m_container);

        QHBoxLayout *horizontalLayout = new QHBoxLayout(m_configWidget);
        horizontalLayout->addLayout(verticalLayout);
        horizontalLayout->addLayout(buttonLayout);

        connect(m_debuggerView->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
                this, SLOT(debuggerSelectionChanged()));

        connect(m_addButton, SIGNAL(clicked()), this, SLOT(addDebugger()), Qt::QueuedConnection);
        connect(m_cloneButton, SIGNAL(clicked()), this, SLOT(cloneDebugger()), Qt::QueuedConnection);
        connect(m_delButton, SIGNAL(clicked()), this, SLOT(removeDebugger()), Qt::QueuedConnection);

        m_itemConfigWidget = new DebuggerItemConfigWidget(m_model);
        m_container->setWidget(m_itemConfigWidget);

        updateState();
    }
    return m_configWidget;
}
void FilesViewer::init()
{
	m_filesTable->setModel(m_model);
	m_filesTable->horizontalHeader()->setSectionsMovable(true);

	QHeaderView* h = m_filesTable->horizontalHeader();
	h->setSectionResizeMode(QHeaderView::Stretch);
	h->setSectionResizeMode(TrackModelFields::Position, QHeaderView::ResizeToContents);
	h->setSectionResizeMode(TrackModelFields::Year, QHeaderView::ResizeToContents);

	m_filesTable->verticalHeader()->setSectionResizeMode(QHeaderView::Fixed);
}
/**
 * @brief EditEntityDialog::EditEntityDialog
 * @param parent
 */
EditEntityDialog::EditEntityDialog(QWidget *parent)
    : QDialog(parent)
    , ui(new Ui::EditEntityDialog)
    , m_EditMethodDialog(new EditMethodDialog(this))
    , m_CommandsStack(new QUndoStack(this))
    , m_ComponentsModel(std::make_shared<models::ComponentsModel>(nullptr))
{
    ui->setupUi(this);

    for(auto &&pair : names)
        ui->cbType->addItem(pair.first, QVariant::fromValue(pair.second));
    for (auto &&p : componentsNames)
        itemByName(p.first, ui->lstMembers)->setData(int(ComponentCustomRoles::Single), p.second);
    for (auto &&p : display)
        itemByName(p.first, ui->lstMembers)->setData(int(ComponentCustomRoles::Display),
                QVariant::fromValue(p.second));

    ui->lstMembers->setCurrentRow(0);
    ui->viewMembers->setModel(m_ComponentsModel.get());

    auto componentsEditDelegat = new ComponentsEditDelegate(this);
    connect(componentsEditDelegat, &ComponentsEditDelegate::editButtonClicked,
            this, &EditEntityDialog::onEditComponentClicked);
    connect(componentsEditDelegat, &ComponentsEditDelegate::deleteButtonClicked,
            this, &EditEntityDialog::onDeleteComponentClicked);
    ui->viewMembers->setItemDelegateForColumn(models::ComponentsModel::Buttons, componentsEditDelegat);
    connect(m_ComponentsModel.get(), &models::ComponentsModel::showButtons,
    [view = ui->viewMembers](auto &&indexes) {
        for (auto &&index: indexes) {
            Q_ASSERT(index.isValid());
            view->openPersistentEditor(index);
        }
    });

    m_SignatureEditDelegate = std::make_unique<SignatureEditDelegate>();
    ui->viewMembers->setItemDelegateForColumn(models::ComponentsModel::ShortSignature, m_SignatureEditDelegate.get());

    QHeaderView * header = ui->viewMembers->horizontalHeader();
    header->setSectionResizeMode(models::ComponentsModel::ShortSignature, QHeaderView::Stretch);
    header->setSectionResizeMode(models::ComponentsModel::Buttons, QHeaderView::Fixed);
    ui->viewMembers->setColumnWidth(models::ComponentsModel::Buttons, componentsEditDelegat->size().width());

    connect(ui->pbAccept, &QPushButton::clicked, this, &EditEntityDialog::onAccepted);
    connect(ui->pbReject, &QPushButton::clicked, this, &EditEntityDialog::onRejected);
    connect(ui->pbCreateScope, &QPushButton::clicked, this, &EditEntityDialog::needNewScope);
    connect(ui->pbNewComponent, &QPushButton::clicked, this, &EditEntityDialog::onNewComponentClicked);
    connect(ui->lstMembers, &QListWidget::currentItemChanged, this, &EditEntityDialog::onCurrentItemChange);

    connect(m_CommandsStack.data(), &QUndoStack::canRedoChanged, ui->tbRedo, &QToolButton::setEnabled);
    connect(m_CommandsStack.data(), &QUndoStack::canUndoChanged, ui->tbUndo, &QToolButton::setEnabled);
    connect(ui->tbRedo, &QToolButton::clicked, m_CommandsStack.data(), &QUndoStack::redo);
    connect(ui->tbUndo, &QToolButton::clicked, m_CommandsStack.data(), &QUndoStack::undo);
}
Exemple #11
0
void DirectoryView::setModel(DirectoryModel* model)
{
	GenericTreeView<DirectoryModel>::setModel(model);

	if(model) {
		QHeaderView* header = this->header();
		header->setStretchLastSection(false);
		header->setSectionResizeMode(0, QHeaderView::Stretch);
		header->setSectionResizeMode(1, QHeaderView::Interactive);
		header->setSectionResizeMode(2, QHeaderView::Interactive);
	}
}
Exemple #12
0
TilesetView::TilesetView(QWidget *parent)
    : QTableView(parent)
    , mZoomable(new Zoomable(this))
    , mTilesetDocument(nullptr)
    , mMarkAnimatedTiles(true)
    , mEditTerrain(false)
    , mEditWangSet(false)
    , mWangBehavior(WholeId)
    , mEraseTerrain(false)
    , mTerrain(nullptr)
    , mWangSet(nullptr)
    , mWangId(0)
    , mWangColorIndex(0)
    , mHoveredCorner(0)
    , mTerrainChanged(false)
    , mWangIdChanged(false)
    , mHandScrolling(false)
    , mImageMissingIcon(QStringLiteral("://images/32x32/image-missing.png"))
{
    setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
    setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
    setItemDelegate(new TileDelegate(this, this));
    setShowGrid(false);
    setTabKeyNavigation(false);

    QHeaderView *hHeader = horizontalHeader();
    QHeaderView *vHeader = verticalHeader();
    hHeader->hide();
    vHeader->hide();
    hHeader->setSectionResizeMode(QHeaderView::ResizeToContents);
    vHeader->setSectionResizeMode(QHeaderView::ResizeToContents);
    hHeader->setMinimumSectionSize(1);
    vHeader->setMinimumSectionSize(1);

    // Hardcode this view on 'left to right' since it doesn't work properly
    // for 'right to left' languages.
    setLayoutDirection(Qt::LeftToRight);

    Preferences *prefs = Preferences::instance();
    mDrawGrid = prefs->showTilesetGrid();

    grabGesture(Qt::PinchGesture);

    connect(prefs, &Preferences::showTilesetGridChanged,
            this, &TilesetView::setDrawGrid);

    connect(StyleHelper::instance(), &StyleHelper::styleApplied,
            this, &TilesetView::updateBackgroundColor);

    connect(mZoomable, &Zoomable::scaleChanged, this, &TilesetView::adjustScale);
}
Exemple #13
0
void batchWindow::updateColumns()
{
	QHeaderView *headerView = ui->tableWidget->horizontalHeader();
	headerView->setSectionResizeMode(QHeaderView::Interactive);
	headerView->resizeSection(0, 60);
	headerView->resizeSection(1, 40);
	headerView->resizeSection(2, 80);
	headerView->setSectionResizeMode(2, QHeaderView::Stretch);
	headerView->resizeSection(3, 80);
	headerView->resizeSection(4, 80);
	headerView->resizeSection(5, 80);
	ui->tableWidget->resizeColumnToContents(0);
	ui->tableWidget->repaint();
}
Exemple #14
0
void GameList::MakeTableView()
{
	m_table = new QTableView(this);
	m_table->setModel(m_table_proxy);
	m_table->setSelectionMode(QAbstractItemView::SingleSelection);
	m_table->setSelectionBehavior(QAbstractItemView::SelectRows);
	m_table->setAlternatingRowColors(true);
	m_table->setShowGrid(false);
	m_table->setSortingEnabled(true);
	m_table->setCurrentIndex(QModelIndex());

	// TODO load from config
	m_table->setColumnHidden(GameListModel::COL_PLATFORM, false);
	m_table->setColumnHidden(GameListModel::COL_ID, true);
	m_table->setColumnHidden(GameListModel::COL_BANNER, false);
	m_table->setColumnHidden(GameListModel::COL_TITLE, false);
	m_table->setColumnHidden(GameListModel::COL_DESCRIPTION, true);
	m_table->setColumnHidden(GameListModel::COL_MAKER, false);
	m_table->setColumnHidden(GameListModel::COL_SIZE, false);
	m_table->setColumnHidden(GameListModel::COL_COUNTRY, false);
	m_table->setColumnHidden(GameListModel::COL_RATING, false);

	QHeaderView* header = m_table->horizontalHeader();
	header->setSectionResizeMode(GameListModel::COL_PLATFORM, QHeaderView::Fixed);
	header->setSectionResizeMode(GameListModel::COL_COUNTRY, QHeaderView::Fixed);
	header->setSectionResizeMode(GameListModel::COL_ID, QHeaderView::ResizeToContents);
	header->setSectionResizeMode(GameListModel::COL_BANNER, QHeaderView::ResizeToContents);
	header->setSectionResizeMode(GameListModel::COL_TITLE, QHeaderView::Stretch);
	header->setSectionResizeMode(GameListModel::COL_MAKER, QHeaderView::Stretch);
	header->setSectionResizeMode(GameListModel::COL_SIZE, QHeaderView::ResizeToContents);
	header->setSectionResizeMode(GameListModel::COL_DESCRIPTION, QHeaderView::Stretch);
	header->setSectionResizeMode(GameListModel::COL_RATING, QHeaderView::Fixed);
}
void LoginDialog::onSessionChoiceNeeded(net::LoginSessionModel *sessions)
{
	sessions->setHideNsfm(parentalcontrols::level() >= parentalcontrols::Level::NoList);
	m_ui->sessionlist->setModel(sessions);

	QHeaderView *header = m_ui->sessionlist->horizontalHeader();
	header->setSectionResizeMode(1, QHeaderView::Stretch);
	header->setSectionResizeMode(0, QHeaderView::Fixed);
	header->resizeSection(0, 24);

	auto updateNsfmLabel = [this, sessions]() {
		const int filtered = sessions->filteredCount();
		if(filtered>0) {
			QString label = tr("%n age restricted session(s) hidden.", "", filtered);
			if(!parentalcontrols::isLocked())
				label = "<a href=\"#\">" + label  + "</a>";
			m_ui->nsfmSessionsLabel->setText(label);
		}
		m_ui->nsfmSessionsLabel->setVisible(filtered>0);
	};

	updateNsfmLabel();
	connect(sessions, &net::LoginSessionModel::filteredCountChanged, this, updateNsfmLabel);
	if(!parentalcontrols::isLocked()) {
		connect(m_ui->nsfmSessionsLabel, &QLabel::linkActivated, this, [this, sessions]() {
			QMessageBox::StandardButton btn = QMessageBox::question(this, QString(), tr("Show age restricted sessions?"));

			if(btn == QMessageBox::Yes) {
				sessions->setHideNsfm(false);
				m_ui->nsfmSessionsLabel->setVisible(false);
				QSettings().setValue("pc/level", int(parentalcontrols::Level::Unrestricted));
			}
		});
	}

	connect(m_ui->sessionlist->selectionModel(), &QItemSelectionModel::selectionChanged, [this](const QItemSelection &sel) {
		// Enable/disable OK button depending on the selection
		bool ok;

		if(sel.indexes().isEmpty())
			ok = false;
		else
			ok = sel.indexes().at(0).data(net::LoginSessionModel::JoinableRole).toBool();

		m_ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(ok);
	});

	resetMode(SESSION);
}
Exemple #16
0
//---------------------------------
PluginKateXMLCheckView::PluginKateXMLCheckView( KTextEditor::Plugin *plugin,
                                                KTextEditor::MainWindow *mainwin)
    : QObject(mainwin)
    , KXMLGUIClient()
    , m_mainWindow(mainwin)
{
    KXMLGUIClient::setComponentName(QLatin1String("katexmlcheck"), i18n ("Kate XML check")); // where i18n resources?
    setXMLFile(QLatin1String("ui.rc"));

    dock = m_mainWindow->createToolView(plugin, "kate_plugin_xmlcheck_ouputview", KTextEditor::MainWindow::Bottom, QIcon::fromTheme("misc"), i18n("XML Checker Output"));
    listview = new QTreeWidget( dock );
    m_tmp_file=0;
    QAction *a = actionCollection()->addAction("xml_check");
    a->setText(i18n("Validate XML"));
    connect(a, SIGNAL(triggered()), this, SLOT(slotValidate()));
    // TODO?:
    //(void)  new KAction ( i18n("Indent XML"), KShortcut(), this,
    //	SLOT(slotIndent()), actionCollection(), "xml_indent" );

    listview->setFocusPolicy(Qt::NoFocus);
    QStringList headers;
    headers << i18n("#");
    headers << i18n("Line");
    headers << i18n("Column");
    headers << i18n("Message");
    listview->setHeaderLabels(headers);
    listview->setRootIsDecorated(false);
    connect(listview, SIGNAL(itemClicked(QTreeWidgetItem*,int)), SLOT(slotClicked(QTreeWidgetItem*,int)));

    QHeaderView *header = listview->header();
    header->setSectionResizeMode(0, QHeaderView::ResizeToContents);
    header->setSectionResizeMode(1, QHeaderView::ResizeToContents);
    header->setSectionResizeMode(2, QHeaderView::ResizeToContents);

/* TODO?: invalidate the listview when document has changed
   Kate::View *kv = application()->activeMainWindow()->activeView();
   if( ! kv ) {
   qDebug() << "Warning: no Kate::View";
   return;
   }
   connect(kv, SIGNAL(modifiedChanged()), this, SLOT(slotUpdate()));
*/

    connect(&m_proc, SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(slotProcExited(int,QProcess::ExitStatus)));
    // we currently only want errors:
    m_proc.setProcessChannelMode(QProcess::SeparateChannels);
    // m_proc.setProcessChannelMode(QProcess::ForwardedChannels); // For Debugging. Do not use this.
    mainwin->guiFactory()->addClient(this);
}
Exemple #17
0
XMLInfoDialog::XMLInfoDialog(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::XMLInfoDialog)
{
    ui->setupUi(this);

    setWindowTitle(tr("选择订阅"));
    setMinimumWidth(400);
    setMinimumHeight(450);
    setMaximumWidth(400);
    setMaximumHeight(450);

    QAbstractButton *okBtn = ui->buttonBox->button(QDialogButtonBox::Ok);
    QAbstractButton *cancelBtn = ui->buttonBox->button(QDialogButtonBox::Cancel);
    okBtn->setText(tr("确定"));
    cancelBtn->setText(tr("取消"));
    connect(cancelBtn, SIGNAL(clicked(bool)), this, SLOT(close()));
    connect(okBtn, SIGNAL(clicked(bool)), this, SLOT(subscriptionSelectedFinished()));

    QHeaderView *header = new QHeaderView(Qt::Horizontal, ui->treeWidget);
    header->setSectionResizeMode(QHeaderView::Stretch);
    header->setDefaultAlignment(Qt::AlignCenter);
    ui->treeWidget->setHeader(header);

    connect(ui->treeWidget, SIGNAL(itemChanged(QTreeWidgetItem*,int)), this, SLOT(treeItemChanged(QTreeWidgetItem*,int)));

}
Exemple #18
0
Sesion::Sesion(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::Sesion)
{
    ui->setupUi(this);

    ui->tableWidget->setEnabled(false);
    ui->tableWidget->setColumnCount(1);
    QHeaderView* header = ui->tableWidget->horizontalHeader();
    header->setSectionResizeMode(0,QHeaderView::Stretch);
    header->setVisible(true);
    QStringList nameLabels;
    nameLabels<<"Aplicaciones";
    ui->tableWidget->setHorizontalHeaderLabels(nameLabels);

    this->windowsAnhadir = new dNewApp();

    ui->btnEditar->setEnabled(false);
    ui->btnEliminar->setEnabled(false);
    //ui->btnUp->setEnabled(false);
    //ui->btnDown->setEnabled(false);

    connect(this->windowsAnhadir,SIGNAL(getData(QString,QString,int,bool)),this,SLOT(newItem(QString,QString,int,bool)));
    connect(ui->btnAnhadir,SIGNAL(clicked()),this,SLOT(anhadirItem()));
    connect(ui->btnEditar,SIGNAL(clicked()),this,SLOT(editarItem()));
    connect(ui->btnEliminar,SIGNAL(clicked()),this,SLOT(eliminarItem()));
    connect(ui->tableWidget,SIGNAL(cellClicked(int,int)),this,SLOT(activarEditarBtn(int,int)));
    connect(ui->tableWidget,SIGNAL(cellPressed(int,int)),this,SLOT(activarEditarBtn(int,int)));
    connect(ui->tableWidget,SIGNAL(cellActivated(int,int)),this,SLOT(activarEditarBtn(int,int)));
}
EditIndexDialog::EditIndexDialog(DBBrowserDB& db, const QString& indexName, bool createIndex, QWidget* parent)
    : QDialog(parent),
      pdb(db),
      curIndex(indexName),
      index(indexName),
      newIndex(createIndex),
      ui(new Ui::EditIndexDialog),
      m_sRestorePointName(pdb.generateSavepointName("editindex"))
{
    // Create UI
    ui->setupUi(this);

    // Get list of tables, sort it alphabetically and fill the combobox
    objectMap dbobjs;
    QList<sqlb::ObjectPtr> tables = pdb.objMap.values("table");
    for(auto it=tables.constBegin();it!=tables.constEnd();++it)
        dbobjs.insert((*it)->name(), (*it));
    ui->comboTableName->blockSignals(true);
    for(auto it=dbobjs.constBegin();it!=dbobjs.constEnd();++it)
        ui->comboTableName->addItem(QIcon(QString(":icons/table")), (*it)->name());
    ui->comboTableName->blockSignals(false);

    QHeaderView *tableHeaderView = ui->tableIndexColumns->horizontalHeader();
    tableHeaderView->setSectionResizeMode(0, QHeaderView::Stretch);

    // Editing an existing index?
    if(!newIndex)
    {
        // Load the current layout and fill in the dialog fields
        index = *(pdb.getObjectByName(curIndex).dynamicCast<sqlb::Index>());

        ui->editIndexName->blockSignals(true);
        ui->editIndexName->setText(index.name());
        ui->editIndexName->blockSignals(false);
        ui->checkIndexUnique->blockSignals(true);
        ui->checkIndexUnique->setChecked(index.unique());
        ui->checkIndexUnique->blockSignals(false);
        ui->comboTableName->blockSignals(true);
        ui->comboTableName->setCurrentText(index.table());
        ui->comboTableName->blockSignals(false);
        ui->editPartialClause->blockSignals(true);
        ui->editPartialClause->setText(index.whereExpr());
        ui->editPartialClause->blockSignals(false);

        tableChanged(index.table(), true);
    } else {
        tableChanged(ui->comboTableName->currentText(), false);
    }

    // Add event handler for index column name changes. These are only allowed for expression columns, though.
    connect(ui->tableIndexColumns, static_cast<void(QTableWidget::*)(QTableWidgetItem*)>(&QTableWidget::itemChanged),
            [=](QTableWidgetItem* item)
    {
        index.columns().at(item->row())->setName(item->text());
        updateSqlText();
    });

    // Create a savepoint to revert back to
    pdb.setSavepoint(m_sRestorePointName);
}
Exemple #20
0
void
MainWindow::
InitializeUi() {

    EnableToolbar(false);

    QHeaderView *header = ui->tableWidget->horizontalHeader();
    header->setSectionResizeMode(QHeaderView::ResizeToContents);
    header->setResizeContentsPrecision(QHeaderView::Stretch);

    connect(ui->actionStep_Run, SIGNAL(triggered(bool)), this, SLOT(StepRun()));
    connect(ui->actionPause, SIGNAL(triggered(bool)), this, SLOT(Stop()));
    connect(ui->actionPlay, SIGNAL(triggered(bool)), this, SLOT(Run()));
    connect(ui->actionConnect, SIGNAL(triggered(bool)), this, SLOT(managePortConnection()));
    connect(ui->pushButton, SIGNAL(pressed()), this, SLOT(SendGroupCommand()));
    connect(ui->actionReset_Script_Table, SIGNAL(triggered(bool)), this, SLOT(ClearTable()));
    connect(ui->tableWidget, SIGNAL(cellPressed(int,int)), this, SLOT(SetRowCol(int,int)));
    connect(ui->actionTimer_Reset, SIGNAL(triggered(bool)), this, SLOT(ResetTimer()));
    connect(ui->actionSave, SIGNAL(triggered(bool)), this, SLOT(SaveScript()));
    connect(ui->actionOpen, SIGNAL(triggered(bool)), this, SLOT(LoadScript()));
    connect(ui->actionExit, SIGNAL(triggered(bool)), this, SLOT(Exit()));

    //////////// RIGHT MOUSE BUTTON MENU /////////////////////////////
    ui->tableWidget->setContextMenuPolicy(Qt::CustomContextMenu);
    connect(ui->tableWidget, SIGNAL(customContextMenuRequested(const QPoint &)),this, SLOT(ShowContextMenu(const QPoint &)));
    //////////////////////////////////////////////////////////////////
}
// ctor.
synthv1widget_controls::synthv1widget_controls ( QWidget *pParent )
	: QTreeWidget(pParent)
{
	QTreeWidget::setColumnCount(4);

	QTreeWidget::setRootIsDecorated(false);
	QTreeWidget::setAlternatingRowColors(true);
	QTreeWidget::setUniformRowHeights(true);
	QTreeWidget::setAllColumnsShowFocus(false);

	QTreeWidget::setSelectionBehavior(QAbstractItemView::SelectRows);
	QTreeWidget::setSelectionMode(QAbstractItemView::SingleSelection);

	QHeaderView *pHeaderView = QTreeWidget::header();
#if QT_VERSION < 0x050000
	pHeaderView->setResizeMode(QHeaderView::ResizeToContents);
#else
	pHeaderView->setSectionResizeMode(QHeaderView::ResizeToContents);
#endif
//	pHeaderView->hide();

	QTreeWidget::setItemDelegate(new synthv1widget_controls_item_delegate(this));

	QObject::connect(this,
		SIGNAL(itemChanged(QTreeWidgetItem *, int)),
		SLOT(itemChangedSlot(QTreeWidgetItem *, int)));
}
AppWindow::AppWindow(QWidget *parent) : QMainWindow(parent),
    ui(new Ui::AppWindow)
{
    main_all_groups_window = new AllGroups();
    group_info_window = new GroupInfo(this);
    main_login_window = new LoginWindow(this);
    myAppWindow = new AppWindowData();

    this->setFixedSize(900, 600);

    connect(this, SIGNAL(sendGroupID(QString)), group_info_window, SLOT(setLabelText(QString)));

    ui->setupUi(this);

    addItemsToCourseNameComboBox();
    resetRowCount();
    setColumnsOfTable();

    main_login_window->show();

    QHeaderView* header = ui->listOfAllGroups->horizontalHeader();
    header->setSectionResizeMode(QHeaderView::Stretch);
    web_interface = HTTPInterface::getInstance();

    ui->deleteButton->hide();
    ui->userdeleteButton_2->hide();
    ui->adminprivButton->hide();
    ui->userlistbox->hide();


}
SyncOverwriteDialog::SyncOverwriteDialog(const QString &path, DirectoryEntry *directoryStructure, QWidget *parent)
  : TutorableDialog("SyncOverwrite", parent),
    ui(new Ui::SyncOverwriteDialog), m_SourcePath(path), m_DirectoryStructure(directoryStructure)
{
  ui->setupUi(this);
  refresh(path);

  QHeaderView *headerView = ui->syncTree->header();
#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
  headerView->setSectionResizeMode(0, QHeaderView::Stretch);
  headerView->setSectionResizeMode(1, QHeaderView::Interactive);
#else
  headerView->setResizeMode(0, QHeaderView::Stretch);
  headerView->setResizeMode(1, QHeaderView::Interactive);
#endif
}
TransitionEditorWindow::TransitionEditorWindow(QWidget* parent)
		: QWidget(parent)
		, ui_(new Ui::TransitionEditorWindow)
		, special_(false)
		, model_(nullptr)
		, transition_(nullptr)
		, transitionType_(TRMControlModel::Transition::TYPE_INVALID)
{
	ui_->setupUi(this);

	ui_->transitionTypeComboBox->addItem(typeNames[2], 2);
	ui_->transitionTypeComboBox->addItem(typeNames[3], 3);
	ui_->transitionTypeComboBox->addItem(typeNames[4], 4);

	ui_->equationsTree->setColumnCount(NUM_EQUATIONS_TREE_COLUMNS);
	ui_->equationsTree->setHeaderLabels(QStringList() << tr("Equation"));

	QFontMetrics fm = fontMetrics();
	int rowHeight = fm.height() + fm.ascent();

	QHeaderView* vHeader = ui_->pointsTable->verticalHeader();
#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
	vHeader->setSectionResizeMode(QHeaderView::Fixed);
#else
	vHeader->setResizeMode(QHeaderView::Fixed);
#endif
	vHeader->setDefaultSectionSize(rowHeight);
	ui_->pointsTable->setColumnCount(NUM_POINTS_TABLE_COLUMNS);
	ui_->pointsTable->setHorizontalHeaderLabels(QStringList() << tr("Type") << tr("Value") << tr("Is phantom?") << tr("Has slope?") << tr("Slope") << tr("Time"));
	//ui_->pointsTable->horizontalHeader()->setResizeMode(QHeaderView::Stretch);

//	QDoubleValidator* validator = new QDoubleValidator(0.0, 1000.0, 1, this);
//	validator->setNotation(QDoubleValidator::StandardNotation);
//	ui_->ruleDurationLineEdit->setValidator(validator);
//	ui_->beatLineEdit->setValidator(validator);
//	ui_->mark1LineEdit->setValidator(validator);
//	ui_->mark2LineEdit->setValidator(validator);
//	ui_->mark3LineEdit->setValidator(validator);

	ui_->ruleDurationSpinBox->setRange(PARAMETERS_MIN, PARAMETERS_MAX);
	ui_->ruleDurationSpinBox->setDecimals(PARAMETERS_DECIMALS);

	ui_->beatSpinBox->setRange(PARAMETERS_MIN, PARAMETERS_MAX);
	ui_->beatSpinBox->setDecimals(PARAMETERS_DECIMALS);

	ui_->mark1SpinBox->setRange(PARAMETERS_MIN, PARAMETERS_MAX);
	ui_->mark1SpinBox->setDecimals(PARAMETERS_DECIMALS);

	ui_->mark2SpinBox->setRange(PARAMETERS_MIN, PARAMETERS_MAX);
	ui_->mark2SpinBox->setDecimals(PARAMETERS_DECIMALS);

	ui_->mark3SpinBox->setRange(PARAMETERS_MIN, PARAMETERS_MAX);
	ui_->mark3SpinBox->setDecimals(PARAMETERS_DECIMALS);

	connect(ui_->transitionWidget, SIGNAL(pointCreationRequested(unsigned int, float, float)), this, SLOT(createPoint(unsigned int, float, float)));
}
RemoteMachineMonitorDialogImpl::RemoteMachineMonitorDialogImpl( QWidget * p, RemoteMachineMonitor* monitor,
                                                               bool runTaskMode )
: QDialog( p ), PING_YES( ":core/images/remote_machine_ping_yes.png" ), PING_NO( ":core/images/remote_machine_ping_no.png" ),
PING_WAIT_FOR_RESPONSE( ":core/images/remote_machine_ping_waiting_response.png" ), PING_QUESTION(":core/images/question.png"),
rmm(monitor), getPublicMachinesTask( NULL ) {
    setupUi( this );

    // add log-view widget
    QVBoxLayout* logLayout = new QVBoxLayout();
    logViewHolder->setLayout(logLayout);
    LogViewWidget* logView = new LogViewWidget(prepareLogFilter());
    logView->setSearchBoxMode(LogViewSearchBox_Hidden);
    logLayout->addWidget(logView);


    currentlySelectedItemIndex = -1;

    assert(rmm != NULL);

    QList< RemoteMachineSettingsPtr > monitorItems = rmm->getRemoteMachineMonitorItems();
    int sz = monitorItems.size();
    for( int i = 0; i < sz; ++i ) {
        const RemoteMachineSettingsPtr& item = monitorItems.at( i );
        addMachineSettings( item, false );
    }
    rsLog.details(tr("Found %1 remote machine records").arg(sz));

    connect( okPushButton, SIGNAL( clicked() ), SLOT( sl_okPushButtonClicked() ) );
    connect( cancelPushButton, SIGNAL( clicked() ), SLOT( sl_cancelPushButtonClicked() ) );
    connect( addPushButton, SIGNAL( clicked() ), SLOT( sl_addPushButtonClicked() ) );
    connect( removePushButton, SIGNAL( clicked() ), SLOT( sl_removePushButtonClicked() ) );
    connect( modifyPushButton, SIGNAL( clicked() ), SLOT( sl_modifyPushButtonClicked() ) );
    connect( showTasksButton, SIGNAL(clicked()), SLOT(sl_showUserTasksButtonClicked()) );
    connect( machinesTreeWidget, SIGNAL( itemSelectionChanged() ), SLOT( sl_selectionChanged() ) );
    connect( pingPushButton, SIGNAL( clicked() ), SLOT( sl_pingPushButtonClicked() ) );
    connect( getPublicMachinesButton, SIGNAL( clicked() ), SLOT( sl_getPublicMachinesButtonClicked() ) );

    okPushButton->setDefault( true );

    QHeaderView * header = machinesTreeWidget->header();
    header->setStretchLastSection( false );
#if (QT_VERSION < 0x050000) //Qt 5
    header->setClickable( false );
    header->setResizeMode( 1, QHeaderView::Stretch );
#else
    header->setSectionsClickable( false );
    header->setSectionResizeMode( 1, QHeaderView::Stretch );
#endif

    if( runTaskMode ) {
        okPushButton->setText( OK_BUTTON_RUN );
    }

    initMachineActionsMenu();
    updateState();
}
UpdateCenterImpl::UpdateCenterImpl(Updates *updates, bool autoDownloadAndInstall, QWidget * parent, Qt::WindowFlags f)
		: QDialog(parent, f)
{
	setupUi(this);
	// resize for macosx
#ifndef Q_OS_WIN32
	resize(630, 366);
#endif
	closedByButton = false;
	// version
	lblxVSTVersion->setText(QString(lblxVSTVersion->text()).arg(PROGRAM_VERSION));
	// set update class
	this->updates = updates;
	// configure updates list
	QStringList headers;
	headers << tr(" File ") << tr(" Version ") << tr(" Size ") << tr(" Progress ");
	// add the headers
	lsvUpdates->setHeaderLabels(headers);
	// change headers sizes
	QFontMetrics fm = fontMetrics();
	QHeaderView *header = lsvUpdates->header();
	// resize
	header->resizeSection(1, fm.width(headers.at(0) + "9.99.999 alpha"));
	header->resizeSection(2, fm.width(headers.at(1) + " 1024,99Mb "));
	// configure resize mode
	header->setHighlightSections(false);
	header->setStretchLastSection(false);
    header->setSectionResizeMode(0, QHeaderView::Stretch);
	// set header text aligment
	QTreeWidgetItem * headerItem = lsvUpdates->headerItem();
	headerItem->setTextAlignment(1, Qt::AlignHCenter | Qt::AlignVCenter);
	headerItem->setTextAlignment(2, Qt::AlignRight   | Qt::AlignVCenter);
	headerItem->setTextAlignment(3, Qt::AlignHCenter | Qt::AlignVCenter);
	// fill data
	fillUpdates();
	// signals
	connect(lsvUpdates, SIGNAL(itemChanged(QTreeWidgetItem*, int)), this, SLOT(itemChanged(QTreeWidgetItem*, int)));
	connect(btnCancel, SIGNAL(clicked()), this, SLOT(btnCancelClicked()));
	connect(btnUpdate, SIGNAL(clicked()), this, SLOT(btnUpdateClicked()));
	// updater
	connect(updates, SIGNAL(downloadingUpdate(int, int, int)), this, SLOT(downloadingUpdate(int, int, int)));
	connect(updates, SIGNAL(downloadUpdateFinished(int)), this, SLOT(downloadUpdateFinished(int)));
	connect(updates, SIGNAL(downloadUpdateError(int)), this, SLOT(downloadUpdateError(int)));
	connect(updates, SIGNAL(downloadsFinished()), this, SLOT(downloadsFinished()));
	connect(updates, SIGNAL(readyToInstallUpdates()), this, SLOT(readyToInstallUpdates()));
	connect(updates, SIGNAL(failedToInstallUpdates()), this, SLOT(failedToInstallUpdates()));
	// if auto download & install updates, then...
	if (autoDownloadAndInstall)
	{
		// disable update button
		lsvUpdates->setEnabled(false);
		btnUpdate->setEnabled(false);
		// start automatically to download updates (in 500ms)
		QTimer::singleShot(500, this, SLOT(btnUpdateClicked()));
	}
}
Exemple #27
0
MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    ui->tableView->setModel(new MultiplicationTableModel(10, 10, this));

    QHeaderView *horizontalHeader = ui->tableView->horizontalHeader();
    if(horizontalHeader)
    {
        horizontalHeader->setSectionResizeMode(QHeaderView::Stretch);
    }

    QHeaderView *verticalHeader = ui->tableView->verticalHeader();
    if(verticalHeader)
    {
        verticalHeader->setSectionResizeMode(QHeaderView::Stretch);
    }
}
Exemple #28
0
TilesetView::TilesetView(QWidget *parent)
    : QTableView(parent)
    , mZoomable(0)
    , mMapDocument(0)
    , mEditTerrain(false)
    , mEraseTerrain(false)
    , mTerrainId(-1)
    , mHoveredCorner(0)
    , mTerrainChanged(false)
{
    setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
    setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
    setItemDelegate(new TileDelegate(this, this));
    setShowGrid(false);

    QHeaderView *hHeader = horizontalHeader();
    QHeaderView *vHeader = verticalHeader();
    hHeader->hide();
    vHeader->hide();
#if QT_VERSION >= 0x050000
    hHeader->setSectionResizeMode(QHeaderView::ResizeToContents);
    vHeader->setSectionResizeMode(QHeaderView::ResizeToContents);
#else
    hHeader->setResizeMode(QHeaderView::ResizeToContents);
    vHeader->setResizeMode(QHeaderView::ResizeToContents);
#endif
    hHeader->setMinimumSectionSize(1);
    vHeader->setMinimumSectionSize(1);

    // Hardcode this view on 'left to right' since it doesn't work properly
    // for 'right to left' languages.
    setLayoutDirection(Qt::LeftToRight);

    Preferences *prefs = Preferences::instance();
    mDrawGrid = prefs->showTilesetGrid();

    grabGesture(Qt::PinchGesture);

    connect(prefs, SIGNAL(showTilesetGridChanged(bool)),
            SLOT(setDrawGrid(bool)));
}
void DischargeItemTable::setVariable(const Quantity * s)
{
    if (_variable != s) {
        _variable = s;
        QStringList headers;
        headers << tr("Radionuclides") << s->displayTextWithUnit();
        setHorizontalHeaderLabels(headers);

        //modify resize mode
        QHeaderView * header = this->horizontalHeader();
        if (header != 0) {
#if QT_VERSION >= 0x050000
            header->setSectionResizeMode(0, QHeaderView::Interactive);
            header->setSectionResizeMode(1, QHeaderView::ResizeToContents);
#else
            header->setResizeMode(0, QHeaderView::Interactive);
            header->setResizeMode(1, QHeaderView::ResizeToContents);
#endif
        }
    }
}
Exemple #30
0
void FormStudents::Init()
{
    ui->tableView->setModel(model);
    ui->tableView->setColumnHidden(0, true);
    ui->tableView->show();
    model->setHeaderData(1, Qt::Horizontal, "ФИО Студента");

    QHeaderView *pHW = ui->tableView->horizontalHeader(); //Нрмальный размер колонок
    int count = pHW->count();
    for (int i = 0; i < count; i++)
        pHW->setSectionResizeMode(i,QHeaderView::ResizeToContents);
}