void ExtendedTableWidget::cellClicked(const QModelIndex& index)
{
// If Ctrl-Shift is pressed try to jump to the row referenced by the foreign key of the clicked cell
if(qApp->keyboardModifiers().testFlag(Qt::ControlModifier) && qApp->keyboardModifiers().testFlag(Qt::ShiftModifier) && model())
{
SqliteTableModel* m = qobject_cast<SqliteTableModel*>(model());
sqlb::ForeignKeyClause fk = m->getForeignKeyClause(index.column()-1);
if(fk.isSet())
emit foreignKeyClicked(sqlb::ObjectIdentifier(m->currentTableName().schema(), fk.table()),
fk.columns().size() ? fk.columns().at(0) : "",
m->data(index, Qt::EditRole).toByteArray());
}
}
void ExtendedTableWidget::updateGeometries()
{
// Call the parent implementation first - it does most of the actual logic
QTableView::updateGeometries();
// Check if a model has already been set yet
if(model())
{
// If so and if it is a SqliteTableModel and if the parent implementation of this method decided that a scrollbar is needed, update its maximum value
SqliteTableModel* m = qobject_cast<SqliteTableModel*>(model());
if(m && verticalScrollBar()->maximum())
verticalScrollBar()->setMaximum(m->rowCount() - numVisibleRows() + 1);
}
}
void ExtendedTableWidget::selectTableLines(int firstLine, int count)
{
SqliteTableModel* m = qobject_cast<SqliteTableModel*>(model());
int lastLine = firstLine+count-1;
// Are there even that many lines?
if(lastLine >= m->rowCount())
return;
selectTableLine(firstLine);
QModelIndex topLeft = m->index(firstLine, 0);
QModelIndex bottomRight = m->index(lastLine, m->columnCount()-1);
selectionModel()->select(QItemSelection(topLeft, bottomRight), QItemSelectionModel::Select | QItemSelectionModel::Rows);
}
void ExtendedTableWidget::selectTableLine(int lineToSelect)
{
SqliteTableModel* m = qobject_cast<SqliteTableModel*>(model());
// Are there even that many lines?
if(lineToSelect >= m->rowCount())
return;
QApplication::setOverrideCursor( Qt::WaitCursor );
m->triggerCacheLoad(lineToSelect);
// Select it
clearSelection();
selectRow(lineToSelect);
scrollTo(currentIndex(), QAbstractItemView::PositionAtTop);
QApplication::restoreOverrideCursor();
}
void ExtendedTableWidget::useAsFilter()
{
QModelIndex index = selectionModel()->currentIndex();
SqliteTableModel* m = qobject_cast<SqliteTableModel*>(model());
// Abort if there's nothing to filter
if (!index.isValid() || !selectionModel()->hasSelection() || m->isBinary(index))
return;
QVariant data = model()->data(index, Qt::EditRole);
if (data.isNull())
m_tableHeader->setFilter(index.column(), "=NULL");
else if (data.toString().isEmpty())
m_tableHeader->setFilter(index.column(), "=''");
else
m_tableHeader->setFilter(index.column(), "=" + data.toString());
}
void ExtendedTableWidget::paste()
{
// Get list of selected items
QItemSelectionModel* selection = selectionModel();
QModelIndexList indices = selection->selectedIndexes();
// Abort if there's nowhere to paste
if(indices.isEmpty())
return;
SqliteTableModel* m = qobject_cast<SqliteTableModel*>(model());
// If clipboard contains image - just insert it
QImage img = qApp->clipboard()->image();
if (!img.isNull()) {
QByteArray ba;
QBuffer buffer(&ba);
buffer.open(QIODevice::WriteOnly);
img.save(&buffer, "PNG");
buffer.close();
m->setData(indices.first(), ba);
return;
}
QString clipboard = qApp->clipboard()->text();
if (clipboard.isEmpty() && !m_buffer.isEmpty()) {
// If buffer contains something - use it instead of clipboard
int rows = m_buffer.size();
int columns = m_buffer.first().size();
int firstRow = indices.front().row();
int firstColumn = indices.front().column();
int lastRow = qMin(firstRow + rows - 1, m->rowCount() - 1);
int lastColumn = qMin(firstColumn + columns - 1, m->columnCount() - 1);
int row = firstRow;
foreach(const QByteArrayList& lst, m_buffer) {
int column = firstColumn;
foreach(const QByteArray& ba, lst) {
m->setData(m->index(row, column), ba);
column++;
if (column > lastColumn)
break;
}
void ExtendedTableWidget::copy()
{
QModelIndexList indices = selectionModel()->selectedIndexes();
// Abort if there's nothing to copy
if (indices.isEmpty())
return;
qSort(indices);
SqliteTableModel* m = qobject_cast<SqliteTableModel*>(model());
// If a single cell is selected, copy it to clipboard
if (indices.size() == 1) {
QImage img;
QVariant data = m->data(indices.first(), Qt::EditRole);
if (img.loadFromData(data.toByteArray())) { // If it's an image
qApp->clipboard()->setImage(img);
return;
} else {
qApp->clipboard()->setText(data.toString());
return;
}
}
m_buffer.clear();
// If any of the cells contain binary data - we use inner buffer
bool containsBinary = false;
foreach (const QModelIndex& index, indices)
if (m->isBinary(index)) {
containsBinary = true;
break;
}
if (containsBinary) {
qApp->clipboard()->clear();
// Copy selected data into inner buffer
int columns = indices.last().column() - indices.first().column() + 1;
while (!indices.isEmpty()) {
QByteArrayList lst;
for (int i = 0; i < columns; ++i) {
lst << indices.first().data(Qt::EditRole).toByteArray();
indices.pop_front();
}
m_buffer.push_back(lst);
}
return;
}
QModelIndex first = indices.first();
QString result;
int currentRow = 0;
foreach(const QModelIndex& index, indices) {
if (first == index) { /* first index */ }
else if (index.row() != currentRow)
result.append("\r\n");
else
result.append("\t");
currentRow = index.row();
QVariant data = index.data(Qt::EditRole);
// non-NULL data is enquoted, whilst NULL isn't
if (!data.isNull()) {
QString text = data.toString();
text.replace("\"", "\"\"");
result.append(QString("\"%1\"").arg(text));
}
}
qApp->clipboard()->setText(result);
}
void ExtendedTableWidget::paste()
{
// Get list of selected items
QItemSelectionModel* selection = selectionModel();
QModelIndexList indices = selection->selectedIndexes();
// Abort if there's nowhere to paste
if(indices.isEmpty())
return;
SqliteTableModel* m = qobject_cast<SqliteTableModel*>(model());
// We're also checking for system clipboard data first. Only if the data in the system clipboard is not ours, we use the system
// clipboard, otherwise we prefer the internal buffer. That's because the data in the internal buffer is easier to parse and more
// accurate, too. However, if we always preferred the internal copy-paste buffer there would be no way to copy data from other
// applications in here once the internal buffer has been filled.
// If clipboard contains an image and no text, just insert the image
const QMimeData* mimeClipboard = qApp->clipboard()->mimeData();
if (mimeClipboard->hasImage() && !mimeClipboard->hasText()) {
QImage img = qApp->clipboard()->image();
QByteArray ba;
QBuffer buffer(&ba);
buffer.open(QIODevice::WriteOnly);
img.save(&buffer, "PNG"); // We're always converting the image format to PNG here. TODO: Is that correct?
buffer.close();
m->setData(indices.first(), ba);
return;
}
// Get the clipboard text
QString clipboard = qApp->clipboard()->text();
// If data in system clipboard is ours and the internal copy-paste buffer is filled, use the internal buffer; otherwise parse the
// system clipboard contents (case for data copied by other application).
QList<QByteArrayList> clipboardTable;
QList<QByteArrayList>* source;
if(mimeClipboard->hasHtml() && mimeClipboard->html().contains(m_generatorStamp) && !m_buffer.isEmpty())
{
source = &m_buffer;
} else {
clipboardTable = parseClipboard(clipboard);
source = &clipboardTable;
}
// Stop here if there's nothing to paste
if(!source->size())
return;
// Starting from assumption that selection is rectangular, and then first index is upper-left corner and last is lower-right.
int rows = source->size();
int columns = source->first().size();
int firstRow = indices.front().row();
int firstColumn = indices.front().column();
int selectedRows = indices.back().row() - firstRow + 1;
int selectedColumns = indices.back().column() - firstColumn + 1;
// If last row and column are after table size, clamp it
int lastRow = qMin(firstRow + rows - 1, m->rowCount() - 1);
int lastColumn = qMin(firstColumn + columns - 1, m->columnCount() - 1);
// Special case: if there is only one cell of data to be pasted, paste it into all selected fields
if(rows == 1 && columns == 1)
{
QByteArray data = source->first().first();
for(int row=firstRow;row<firstRow+selectedRows;row++)
{
for(int column=firstColumn;column<firstColumn+selectedColumns;column++)
m->setData(m->index(row, column), data);
}
return;
}
// If more than one cell was selected, check if the selection matches the cliboard dimensions
if(selectedRows != rows || selectedColumns != columns)
{
// Ask user if they are sure about this
if(QMessageBox::question(this, QApplication::applicationName(),
tr("The content of the clipboard is bigger than the range selected.\nDo you want to insert it anyway?"),
QMessageBox::Yes | QMessageBox::No) != QMessageBox::Yes)
{
// If the user doesn't want to paste the clipboard data anymore, stop now
return;
}
}
// If we get here, we can definitely start pasting: either the ranges match in their size or the user agreed to paste anyway
// Copy the data cell by cell and as-is from the source buffer to the table
int row = firstRow;
for(const QByteArrayList& source_row : *source)
{
int column = firstColumn;
for(const QByteArray& source_cell : source_row)
{
m->setData(m->index(row, column), source_cell);
column++;
if (column > lastColumn)
break;
}
row++;
if (row > lastRow)
break;
}
}
void ExtendedTableWidget::copy(const bool withHeaders)
{
QModelIndexList indices = selectionModel()->selectedIndexes();
// Remove all indices from hidden columns, because if we don't we might copy data from hidden columns as well which is very
// unintuitive; especially copying the rowid column when selecting all columns of a table is a problem because pasting the data
// won't work as expected.
QMutableListIterator<QModelIndex> i(indices);
while (i.hasNext()) {
if (isColumnHidden(i.next().column()))
i.remove();
}
// Abort if there's nothing to copy
if (indices.isEmpty())
return;
SqliteTableModel* m = qobject_cast<SqliteTableModel*>(model());
// Clear internal copy-paste buffer
m_buffer.clear();
// If a single cell is selected, copy it to clipboard
if (!withHeaders && indices.size() == 1) {
QImage img;
QVariant data = m->data(indices.first(), Qt::EditRole);
if (img.loadFromData(data.toByteArray()))
{
// If it's an image, copy the image data to the clipboard
qApp->clipboard()->setImage(img);
return;
} else {
// It it's not an image, check if it's an empty field
if (data.toByteArray().isEmpty())
{
// The field is either NULL or empty. Those are are handled via the internal copy-paste buffer
qApp->clipboard()->setText(QString()); // Calling clear() alone doesn't seem to work on all systems
qApp->clipboard()->clear();
m_buffer.push_back(QByteArrayList{data.toByteArray()});
return;
}
// The field isn't empty. Copy the text to the clipboard without quoting (for general plain text clipboard)
qApp->clipboard()->setText(data.toByteArray());
return;
}
}
// If we got here, there are multiple selected cells, or copy with headers was requested.
// In this case, we copy selected data into internal copy-paste buffer and then
// we write a table both in HTML and text formats to the system clipboard.
// Copy selected data into internal copy-paste buffer
int last_row = indices.first().row();
QByteArrayList lst;
for(int i=0;i<indices.size();i++)
{
if(indices.at(i).row() != last_row)
{
m_buffer.push_back(lst);
lst.clear();
}
lst << indices.at(i).data(Qt::EditRole).toByteArray();
last_row = indices.at(i).row();
}
m_buffer.push_back(lst);
QString result;
QString htmlResult = "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">";
htmlResult.append("<html><head><meta http-equiv=\"content-type\" content=\"text/html; charset=utf-8\">");
htmlResult.append("<title></title>");
// The generator-stamp is later used to know whether the data in the system clipboard is still ours.
// In that case we will give precedence to our internal copy buffer.
QString now = QDateTime::currentDateTime().toString("YYYY-MM-DDTHH:mm:ss.zzz");
m_generatorStamp = QString("<meta name=\"generator\" content=\"%1\"><meta name=\"date\" content=\"%2\">").arg(QApplication::applicationName().toHtmlEscaped(), now);
htmlResult.append(m_generatorStamp);
// TODO: is this really needed by Excel, since we use <pre> for multi-line cells?
htmlResult.append("<style type=\"text/css\">br{mso-data-placement:same-cell;}</style></head><body><table>");
int currentRow = indices.first().row();
const QString fieldSepHtml = "</td><td>";
const QString rowSepHtml = "</td></tr><tr><td>";
const QString fieldSepText = "\t";
const QString rowSepText = "\r\n";
// Table headers
if (withHeaders) {
htmlResult.append("<tr><th>");
int firstColumn = indices.front().column();
for(int i = firstColumn; i <= indices.back().column(); i++) {
QByteArray headerText = model()->headerData(i, Qt::Horizontal, Qt::DisplayRole).toByteArray();
if (i != firstColumn) {
result.append(fieldSepText);
htmlResult.append("</th><th>");
}
result.append(escapeCopiedData(headerText));
htmlResult.append(headerText);
}
result.append(rowSepText);
htmlResult.append("</th></tr>");
}
// Table data rows
for(const QModelIndex& index : indices) {
// Separators. For first cell, only opening table row tags must be added for the HTML and nothing for the text version.
if (indices.first() == index)
htmlResult.append("<tr><td>");
else if (index.row() != currentRow) {
result.append(rowSepText);
htmlResult.append(rowSepHtml);
} else {
result.append(fieldSepText);
htmlResult.append(fieldSepHtml);
}
currentRow = index.row();
QImage img;
QVariant data = index.data(Qt::EditRole);
// Table cell data: image? Store it as an embedded image in HTML and as base 64 in text version
if (img.loadFromData(data.toByteArray()))
{
QByteArray ba;
QBuffer buffer(&ba);
buffer.open(QIODevice::WriteOnly);
img.save(&buffer, "PNG");
buffer.close();
QString imageBase64 = ba.toBase64();
htmlResult.append("<img src=\"data:image/png;base64,");
htmlResult.append(imageBase64);
result.append(QString());
htmlResult.append("\" alt=\"Image\">");
} else {
QByteArray text;
if (!m->isBinary(index))
text = data.toByteArray();
// Table cell data: text
if (text.contains('\n') || text.contains('\t'))
htmlResult.append("<pre>" + QString(text).toHtmlEscaped() + "</pre>");
else
htmlResult.append(QString(text).toHtmlEscaped());
result.append(escapeCopiedData(text));
}
}
QMimeData *mimeData = new QMimeData;
mimeData->setHtml(htmlResult + "</td></tr></table></body></html>");
mimeData->setText(result);
qApp->clipboard()->setMimeData(mimeData);
}
