: QAbstractItemModel(parent),

m_db(db),

browsablesRootItem(nullptr),

m_dropQualifiedNames(false),

m_dropEnquotedNames(false)

{

// Create root item and use its columns to store the header strings

QStringList header;

header << tr("Name") << tr("Object") << tr("Type") << tr("Schema") << tr("Database");

rootItem = new QTreeWidgetItem(header);

{

if(!index.isValid())

return QVariant();

// Get the item the index points at

QTreeWidgetItem* item = static_cast<QTreeWidgetItem*>(index.internalPointer());

// Depending on the role either return the text or the icon

switch(role)

{

case Qt::DisplayRole:

// For the display role and the browsable branch of the tree we want to show the column name including the schema name if necessary (i.e.

// for schemata != "main"). For the normal structure branch of the tree we don't want to add the schema name because it's already obvious from

// the position of the item in the tree.

if(index.column() == ColumnName && item->parent() == browsablesRootItem)

return QString::fromStdString(sqlb::ObjectIdentifier(item->text(ColumnSchema).toStdString(), item->text(ColumnName).toStdString()).toDisplayString());

else

return Settings::getValue("db", "hideschemalinebreaks").toBool() ? item->text(index.column()).replace("\n", " ").simplified() : item->text(index.column());

case Qt::EditRole:

return item->text(index.column());

case Qt::ToolTipRole: {

// Show the original text but limited, when it's supposed to be shown in a tooltip

QString text = item->text(index.column());

if (text.length() > 512) {

text.truncate(509);

text.append("...");

}

return text;

}

case Qt::DecorationRole:

return item->icon(index.column());

default:

return QVariant();

}

{

if(!index.isValid())

return Qt::ItemIsDropEnabled;

// All items are enabled and selectable

Qt::ItemFlags flags = Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDropEnabled;

// Only enable dragging for SQLite objects and for fields (composition in SQL text editor).

// Grouping nodes have no type.

QString type = data(index.sibling(index.row(), ColumnObjectType), Qt::DisplayRole).toString();

if(!type.isEmpty())

flags |= Qt::ItemIsDragEnabled;

return flags;

{

// Get the header string from the root item

if(orientation == Qt::Horizontal && role == Qt::DisplayRole)

return rootItem->data(section, role);

return QVariant();

{

if(!hasIndex(row, column, parent))

return QModelIndex();

QTreeWidgetItem *parentItem;

if(!parent.isValid())

parentItem = rootItem;

else

parentItem = static_cast<QTreeWidgetItem*>(parent.internalPointer());

QTreeWidgetItem* childItem = parentItem->child(row);

if(childItem)

return createIndex(row, column, childItem);

else

return QModelIndex();

{

if(!index.isValid())

return QModelIndex();

QTreeWidgetItem* childItem = static_cast<QTreeWidgetItem*>(index.internalPointer());

QTreeWidgetItem* parentItem = childItem->parent();

if(parentItem == rootItem)

return QModelIndex();

else

return createIndex(0, 0, parentItem);

{

if(parent.column() > 0)

return 0;

if(!parent.isValid())

return rootItem->childCount();

else

return static_cast<QTreeWidgetItem*>(parent.internalPointer())->childCount();

{

beginResetModel();

// Remove all data except for the root item

while(rootItem->childCount())

delete rootItem->child(0);

// Return here if no DB is opened

if(!m_db.isOpen())

{

endResetModel();

emit structureUpdated();

return;

}

// Create the nodes for browsables and for tables, indices, views and triggers. The idea here is to basically have two trees in one model:

// In the root node there are two nodes: 'browsables' and 'all'. The first node contains a list of all browsable objects, i.e. views and tables.

// The second node contains four sub-nodes (tables, indices, views and triggers), each containing a list of objects of that type.

// This way we only have to have and only have to update one model and can use it in all sorts of places, just by setting a different root node.

browsablesRootItem = new QTreeWidgetItem(rootItem);

browsablesRootItem->setIcon(ColumnName, IconCache::get("view"));

browsablesRootItem->setText(ColumnName, tr("Browsables"));

// Make sure to always load the main schema first

QTreeWidgetItem* itemAll = new QTreeWidgetItem(rootItem);

itemAll->setIcon(ColumnName, IconCache::get("database"));

itemAll->setText(ColumnName, tr("All"));

itemAll->setText(ColumnObjectType, "database");

buildTree(itemAll, "main");

// Add the temporary database as a node if it isn't empty. Make sure it's always second if it exists.

if(!m_db.schemata["temp"].empty())

{

QTreeWidgetItem* itemTemp = new QTreeWidgetItem(itemAll);

itemTemp->setIcon(ColumnName, IconCache::get("database"));

itemTemp->setText(ColumnName, tr("Temporary"));

itemTemp->setText(ColumnObjectType, "database");

buildTree(itemTemp, "temp");

}

// Now load all the other schemata last

for(const auto& it : m_db.schemata)

{

// Don't load the main and temp schema again

if(it.first != "main" && it.first != "temp")

{

QTreeWidgetItem* itemSchema = new QTreeWidgetItem(itemAll);

itemSchema->setIcon(ColumnName, IconCache::get("database"));

itemSchema->setText(ColumnName, QString::fromStdString(it.first));

itemSchema->setText(ColumnObjectType, "database");

buildTree(itemSchema, it.first);

}

}

// Refresh the view

endResetModel();

emit structureUpdated();

{

QStringList types;

types << "text/plain";

return types;

{

if(action == Qt::IgnoreAction)

return true;

if(!data->hasFormat("text/plain"))

return false;

if(data->property("db_file") == m_db.currentFile())

return false;

// Get data

QByteArray d = data->data("text/plain");

// Try to execute the SQL statement

if(m_db.executeMultiSQL(d, true, true))

{

m_db.updateSchema();

return true;

} else {

QMessageBox::warning(nullptr, QApplication::applicationName(), m_db.lastError());

return false;

}

{

auto objects = objmap.equal_range(type);

if(objects.first == objmap.end())

return 0;

else

return std::distance(objects.first, objects.second);

{

// Build a map from object type to tree node to simplify finding the correct tree node later

std::unordered_map<std::string, QTreeWidgetItem*> typeToParentItem;

// Get object map for the given schema

objectMap objmap = m_db.schemata[schema];

// Prepare tree

QTreeWidgetItem* itemTables = new QTreeWidgetItem(parent);

itemTables->setIcon(ColumnName, IconCache::get("table"));

itemTables->setText(ColumnName, tr("Tables (%1)").arg(calc_number_of_objects_by_type(objmap, "table")));

typeToParentItem.insert({"table", itemTables});

QTreeWidgetItem* itemIndices = new QTreeWidgetItem(parent);

itemIndices->setIcon(ColumnName, IconCache::get("index"));

itemIndices->setText(ColumnName, tr("Indices (%1)").arg(calc_number_of_objects_by_type(objmap, "index")));

typeToParentItem.insert({"index", itemIndices});

QTreeWidgetItem* itemViews = new QTreeWidgetItem(parent);

itemViews->setIcon(ColumnName, IconCache::get("view"));

itemViews->setText(ColumnName, tr("Views (%1)").arg(calc_number_of_objects_by_type(objmap, "view")));

typeToParentItem.insert({"view", itemViews});

QTreeWidgetItem* itemTriggers = new QTreeWidgetItem(parent);

itemTriggers->setIcon(ColumnName, IconCache::get("trigger"));

itemTriggers->setText(ColumnName, tr("Triggers (%1)").arg(calc_number_of_objects_by_type(objmap, "trigger")));

typeToParentItem.insert({"trigger", itemTriggers});

// Get all database objects and sort them by their name

std::map<std::string, sqlb::ObjectPtr> dbobjs;

for(const auto& it : objmap)

dbobjs.insert({it.second->name(), it.second});

// Add the database objects to the tree nodes

for(const auto& obj : dbobjs)

{

sqlb::ObjectPtr it = obj.second;

// Object node

QTreeWidgetItem* item = addNode(typeToParentItem.at(sqlb::Object::typeToString(it->type())), it, schema);

// If it is a table or view add the field nodes, add an extra node for the browsable section

if(it->type() == sqlb::Object::Types::Table || it->type() == sqlb::Object::Types::View)

addNode(browsablesRootItem, it, schema);

// Add field nodes if there are any

sqlb::FieldInfoList fieldList = it->fieldInformation();

if(!fieldList.empty())

{

sqlb::StringVector pk_columns;

if(it->type() == sqlb::Object::Types::Table)

{

const auto pk = std::dynamic_pointer_cast<sqlb::Table>(it)->primaryKey();

if(pk)

pk_columns = pk->columnList();

}

for(const sqlb::FieldInfo& field : fieldList)

{

QTreeWidgetItem *fldItem = new QTreeWidgetItem(item);

bool isFK = false;

if(it->type() == sqlb::Object::Types::Table)

isFK = std::dynamic_pointer_cast<sqlb::Table>(it)->constraint({field.name}, sqlb::Constraint::ForeignKeyConstraintType) != nullptr;

fldItem->setText(ColumnName, QString::fromStdString(field.name));

fldItem->setText(ColumnObjectType, "field");

fldItem->setText(ColumnDataType, QString::fromStdString(field.type));

fldItem->setText(ColumnSQL, QString::fromStdString(field.sql));

fldItem->setText(ColumnSchema, QString::fromStdString(schema));

if(contains(pk_columns, field.name))

fldItem->setIcon(ColumnName, IconCache::get("field_key"));

else if(isFK)

fldItem->setIcon(ColumnName, IconCache::get("field_fk"));

else

fldItem->setIcon(ColumnName, IconCache::get("field"));

}

}

}

{

// Take into account the drag&drop options for composing a name. Commas are included for composing a

// list of fields. A dot is added after other items, in order to allow composing a fully qualified name

// by selecting together and dropping a parent item and a child (e.g. select with control an attached

// database and a table, and drag and drop them to get "schema1"."table1".) Note that this only makes

// sense when the "Drop Qualified Names" option is not set.

QString name;

if ((domain != "main" && m_dropQualifiedNames) || object.isEmpty())

name = m_dropEnquotedNames ? sqlb::escapeIdentifier(domain) + "." : domain + ".";

if (!object.isEmpty() && (m_dropQualifiedNames || field.isEmpty()))

name += m_dropEnquotedNames ? sqlb::escapeIdentifier(object) + "." : object + ".";

if (!field.isEmpty())

name += m_dropEnquotedNames ? sqlb::escapeIdentifier(field) + ", " : field + ", ";

return name;