pgLab/pglab/TablesPage.cpp

#include "TablesPage.h"
#include "ui_TablesPage.h"

#include "PgAttribute.h"
#include "PgDatabaseCatalog.h"
#include "ColumnTableModel.h"
#include "ConstraintModel.h"
#include "IconColumnDelegate.h"
#include "IndexModel.h"
#include "MainWindow.h"
#include "PgLabItemDelegate.h"
#include "PropertiesPage.h"
#include "ResultTableModelUtil.h"
#include "SqlFormattingUtils.h"
#include "SqlSyntaxHighlighter.h"
#include "TablesTableModel.h"
#include "TriggerPage.h"
#include "UserConfiguration.h"
#include <QStringBuilder>
#include <boost/container/flat_set.hpp>

TablesPage::TablesPage(MainWindow *parent)
	: QWidget(parent)
	, ui(new Ui::TablesPage)
	, m_window(parent)
{
	ui->setupUi(this);

	// WARNING delegates should NOT be shared!!!
	auto pglab_delegate = new PgLabItemDelegate(this);
	auto icon_delegate = new IconColumnDelegate(this);

	SetTableViewDefault(ui->tableListTable);
	m_tablesModel = new TablesTableModel(this);
	ui->tableListTable->setModel(m_tablesModel);
	ui->tableListTable->setItemDelegate(pglab_delegate);
	ui->tableListTable->setSortingEnabled(true);
	ui->tableListTable->sortByColumn(0, Qt::AscendingOrder);
	ui->tableListTable->setSelectionBehavior(QAbstractItemView::SelectRows);

	// Columns
	SetTableViewDefault(ui->columnsTable);
	m_columnsModel = new ColumnTableModel(this);
	ui->columnsTable->setModel(m_columnsModel);

	// Constraints
	SetTableViewDefault(ui->constraintsTable);
	m_constraintModel = new ConstraintModel(this);
	ui->constraintsTable->setModel(m_constraintModel);
	ui->constraintsTable->setItemDelegateForColumn(0, icon_delegate);

	// Indexes
	SetTableViewDefault(ui->indexesTable);
	m_indexModel = new IndexModel(this);
	ui->indexesTable->setModel(m_indexModel);
	ui->indexesTable->setItemDelegate(pglab_delegate);
	ui->indexesTable->setItemDelegateForColumn(0, icon_delegate);

	// Set code editor fonts
	QFont code_font = UserConfiguration::instance()->codeFont();
	ui->constraintSqlEdit->setFont(code_font);
	ui->indexSqlEdit->setFont(code_font);


	// Connect signals
	// ---------------
	// Table selection
	connect(ui->tableListTable->selectionModel(), &QItemSelectionModel::currentRowChanged, this,
			&TablesPage::tableListTable_currentRowChanged);

	connect(m_tablesModel, &QAbstractItemModel::layoutChanged,
			this, &TablesPage::tableListTable_layoutChanged);

	//layoutChanged(const QList<QPersistentModelIndex> &parents = ..., QAbstractItemModel::LayoutChangeHint hint = ...)

	connect(ui->constraintsTable->selectionModel(), &QItemSelectionModel::selectionChanged, this,
			&TablesPage::constraintsTable_selectionChanged);
	connect(ui->constraintsTable->model(), &QAbstractItemModel::modelReset, this,
			&TablesPage::constraintsTable_modelReset);

	// React to changes in de selected indexes, does not trigger when model is reset
	connect(ui->indexesTable->selectionModel(), &QItemSelectionModel::selectionChanged, this,
			&TablesPage::indexesTable_selectionChanged);
	// Capture model reset independently
	connect(ui->indexesTable->model(), &QAbstractItemModel::modelReset, this,
			&TablesPage::indexesTable_modelReset);

	// Non designer based code
	// - Properties page
	m_propertiesPage = new PropertiesPage(this);
	m_propertiesPage->setSourceModel(m_tablesModel);
	m_propertiesTab = addDetailTab(m_propertiesPage);
	connect(ui->tableListTable->selectionModel(), &QItemSelectionModel::currentRowChanged,
			m_propertiesPage, &PropertiesPage::setActiveRow);

	// - Trigger page
	m_triggerPage = new TriggerPage(this);
	m_triggerTab = addDetailTab(m_triggerPage);

	retranslateUi(false);
}


void TablesPage::retranslateUi(bool all)
{
	if (all)
		ui->retranslateUi(this);

	ui->twDetails->setTabText(ui->twDetails->indexOf(m_propertiesTab), QApplication::translate("TablesPage", "Properties", nullptr));
	ui->twDetails->setTabText(ui->twDetails->indexOf(m_triggerTab), QApplication::translate("TablesPage", "Triggers", nullptr));
}


QWidget* TablesPage::addDetailTab(QWidget *contents)
{
	auto tab = new QWidget();
	auto verticalLayout = new QVBoxLayout(tab);
	verticalLayout->addWidget(contents);
	ui->twDetails->addTab(tab, "");
	return tab;
}

TablesPage::~TablesPage()
{
	delete ui;
}

void TablesPage::setCatalog(std::shared_ptr<PgDatabaseCatalog> cat)
{
	m_catalog = cat;
	m_tablesModel->setCatalog(cat);
	ui->tableListTable->resizeColumnsToContents();

	m_triggerPage->setCatalog(cat);

	auto highlighter = new SqlSyntaxHighlighter(ui->constraintSqlEdit->document());
	highlighter->setTypes(*cat->types());
	highlighter = new SqlSyntaxHighlighter(ui->indexSqlEdit->document());
	highlighter->setTypes(*cat->types());
}


void TablesPage::tableListTable_currentRowChanged(const QModelIndex &current, const QModelIndex &previous)
{
	if (current.row() != previous.row()) {
		PgClass table = m_tablesModel->getTable(current.row());
		selectedTableChanged(table);
	}
}


void TablesPage::tableListTable_layoutChanged(const QList<QPersistentModelIndex> &, QAbstractItemModel::LayoutChangeHint )
{
	auto&& index = ui->tableListTable->selectionModel()->currentIndex();
	PgClass table = m_tablesModel->getTable(index.row());
	selectedTableChanged(table);
}


void TablesPage::selectedTableChanged(const PgClass & table)
{
	m_columnsModel->setData(m_catalog, table);
	ui->columnsTable->resizeColumnsToContents();

	m_constraintModel->setData(m_catalog, table);
	ui->constraintsTable->resizeColumnsToContents();
	ui->constraintsTable->selectionModel()->reset();

	m_indexModel->setData(m_catalog, table);
	ui->indexesTable->resizeColumnsToContents();

	m_triggerPage->setFilter(table);
}


void TablesPage::constraintsTable_selectionChanged(const QItemSelection &/*selected*/, const QItemSelection &/*deselected*/)
{
	const auto indexes = ui->constraintsTable->selectionModel()->selectedIndexes();
	boost::container::flat_set<int> rijen;
	for (const auto &e : indexes)
		rijen.insert(e.row());

	QString drops;
	QString creates;
	for (auto rij : rijen) {
		const PgConstraint constraint = m_constraintModel->constraint(rij);
		drops += getDropConstraintDefinition(*m_catalog, constraint) % "\n";
		creates += getConstraintDefinition(*m_catalog, constraint) % "\n";
	}
	ui->constraintSqlEdit->setPlainText(drops % "\n" % creates);
}

void TablesPage::constraintsTable_modelReset()
{
	ui->constraintSqlEdit->clear();
}

void TablesPage::indexesTable_selectionChanged(const QItemSelection &/*selected*/, const QItemSelection &/*deselected*/)
{
	const auto indexes = ui->indexesTable->selectionModel()->selectedIndexes();
	boost::container::flat_set<int> rijen;
	for (const auto &e : indexes)
		rijen.insert(e.row());

	QString drops;
	QString creates;
	for (auto rij : rijen) {
		const PgIndex index = m_indexModel->getIndex(rij);
		drops += getDropIndexDefinition(*m_catalog, index) % "\n";
		creates += getIndexDefinition(*m_catalog, index) % "\n";
	}
	ui->indexSqlEdit->setPlainText(drops % "\n" % creates);

}

void TablesPage::indexesTable_modelReset()
{
	ui->indexSqlEdit->clear();
}

void TablesPage::on_tableListTable_doubleClicked(const QModelIndex &index)
{
	PgClass table = m_tablesModel->getTable(index.row());
	if (table.oid != InvalidOid) {
		m_window->newCrudPage(table);
	}

}