: QAbstractListModel(parent)

{

m_invalidTab = new Tab(this, false);

m_activeTab = m_invalidTab;

{

Q_UNUSED(parent)

return m_tabsList.length();

{

Tab* tab = get(index.row());

switch(role) {

case Uid:

return QVariant(tab->uid());

case Url:

return QVariant(tab->url());

case Title:

return QVariant(tab->title());

case IconUrl:

return QVariant(tab->iconUrl());

case CanGoBack:

return QVariant(tab->canGoBack());

case CanGoForward:

return QVariant(tab->canGoForward());

case Loading:

return QVariant(tab->loading());

case LoadProgress:

return QVariant(tab->loadProgress());

case Valid:

return QVariant(tab->valid());

}

return QVariant();

{

QHash<int, QByteArray> roles;

roles[Uid] = "uid";

roles[Url] = "url";

roles[Title] = "title";

roles[IconUrl] = "iconUrl";

roles[CanGoBack] = "canGoBack";

roles[CanGoForward] = "canGoForward";

roles[Loading] = "loading";

roles[LoadProgress] = "loadProgress";

roles[Valid] = "valid";

return roles;

{

// Append tab at the end

insert(uid, -1);

{

// Append at the end if no row is given

if (row == -1)

row = rowCount();

beginInsertRows(QModelIndex(), row, row);

Tab* tab = new Tab(this);

tab->setUid(uid);

m_tabsList.insert(row, tab);

countChanged(count());

emptyChanged(false);

endInsertRows();

{

if (fromRow == toRow)

return false;

if (fromRow >= rowCount() || toRow >= rowCount())

return false;

// QList's and QAbstractItemModel's move implementation differ when moving an item up the list :/

// While QList needs the index in the resulting list, beginMoveRows expects it to be in the current list

// adjust the model's index by +1 in case we're moving upwards

// Thanks to Michael Zanetti

int newToRow = toRow > fromRow ? toRow + 1 : toRow;

beginMoveRows(QModelIndex(), fromRow, fromRow, QModelIndex(), newToRow);

m_tabsList.move(fromRow, toRow);

// Update active index

activeIndexChanged(activeIndex());

endMoveRows();

return true;

{

int index = m_tabsList.indexOf(tab);

if (index == -1)

return false;

int activeIdx = activeIndex();

// Call signal before removing and deleting tab

beforeTabRemoved(tab);

beginRemoveRows(QModelIndex(), index, index);

m_tabsList.removeAt(index);

// Remove tab from active tab history

m_activeTabHistory.removeAll(tab);

tab->deleteLater();

// Update count and empty

countChanged(count());

emptyChanged(empty());

// Active tab is replaced by invalid dummy tab

if (empty()) {

m_activeTab = m_invalidTab;

}

endRemoveRows();

if (index == activeIdx) {

setActive(!m_activeTabHistory.empty()

? m_activeTabHistory.last()

: m_tabsList.first(),

false);

} else if (index < activeIdx) {

return setActive(active(), false);

}

m_activeTabHistory.removeAll(tab);

return true;

{

if (m_activeTab == tab)

setInactive(tab);

{

if (m_activeTab == m_tabsList.first() && m_tabsList.length() > 1) {

return setActive(m_tabsList.last(), true);

}

return activateTabRelativeToCurrent(-1);

{

if (m_activeTab == m_tabsList.last() && m_tabsList.length() > 1) {

return setActive(m_tabsList.first(), true);

}

return activateTabRelativeToCurrent(1);

{

if (m_tabsList.length() == 0) {

activeChanged(m_activeTab = m_invalidTab);

activeIndexChanged(activeIndex());

return false;

}

int currIndex = activeIndex();

if (currIndex == -1) {

setActive(m_tabsList.last(), true);

return true;

}

int newIndex = currIndex + offset;

if (newIndex < 0 || newIndex >= m_tabsList.length()) {

return false;

}

return setActive(m_tabsList.at(newIndex), true);

{

if (!tab->valid())

return false;

// Adding previously active tab to history

// so currently active tab is not a last member of history

if (recordToHistory) {

m_activeTabHistory.append(m_activeTab);

}

m_activeTab = tab;

activeChanged(tab);

activeIndexChanged(activeIndex());

return true;