NOISSUE move everything.

8 files changed, 1974 insertions, 0 deletions

diff --git a/application/groupview/GroupView.cpp b/application/groupview/GroupView.cpp
new file mode 100644
index 00000000..89694b87
--- /dev/null
+++ b/application/groupview/GroupView.cpp
@@ -0,0 +1,1003 @@
+#include "GroupView.h"
+
+#include <QPainter>
+#include <QApplication>
+#include <QtMath>
+#include <QMouseEvent>
+#include <QListView>
+#include <QPersistentModelIndex>
+#include <QDrag>
+#include <QMimeData>
+#include <QCache>
+#include <QScrollBar>
+
+#include "VisualGroup.h"
+#include <QDebug>
+
+template <typename T> bool listsIntersect(const QList<T> &l1, const QList<T> t2)
+{
+	for (auto &item : l1)
+	{
+		if (t2.contains(item))
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+GroupView::GroupView(QWidget *parent)
+	: QAbstractItemView(parent)
+{
+	setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+	setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
+	setAcceptDrops(true);
+	setAutoScroll(true);
+}
+
+GroupView::~GroupView()
+{
+	qDeleteAll(m_groups);
+	m_groups.clear();
+}
+
+void GroupView::setModel(QAbstractItemModel *model)
+{
+	QAbstractItemView::setModel(model);
+	connect(model, &QAbstractItemModel::modelReset, this, &GroupView::modelReset);
+}
+
+void GroupView::dataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight,
+							const QVector<int> &roles)
+{
+	scheduleDelayedItemsLayout();
+}
+void GroupView::rowsInserted(const QModelIndex &parent, int start, int end)
+{
+	scheduleDelayedItemsLayout();
+}
+
+void GroupView::rowsAboutToBeRemoved(const QModelIndex &parent, int start, int end)
+{
+	scheduleDelayedItemsLayout();
+}
+
+class LocaleString : public QString
+{
+public:
+	LocaleString(const char *s) : QString(s)
+	{
+	}
+	LocaleString(const QString &s) : QString(s)
+	{
+	}
+};
+
+inline bool operator<(const LocaleString &lhs, const LocaleString &rhs)
+{
+	return (QString::localeAwareCompare(lhs, rhs) < 0);
+}
+
+void GroupView::updateGeometries()
+{
+	geometryCache.clear();
+	int previousScroll = verticalScrollBar()->value();
+
+	QMap<LocaleString, VisualGroup *> cats;
+
+	for (int i = 0; i < model()->rowCount(); ++i)
+	{
+		const QString groupName =
+			model()->index(i, 0).data(GroupViewRoles::GroupRole).toString();
+		if (!cats.contains(groupName))
+		{
+			VisualGroup *old = this->category(groupName);
+			if (old)
+			{
+				cats.insert(groupName, new VisualGroup(old));
+			}
+			else
+			{
+				cats.insert(groupName, new VisualGroup(groupName, this));
+			}
+		}
+	}
+
+	/*if (m_editedCategory)
+	{
+		m_editedCategory = cats[m_editedCategory->text];
+	}*/
+
+	qDeleteAll(m_groups);
+	m_groups = cats.values();
+
+	for (auto cat : m_groups)
+	{
+		cat->update();
+	}
+
+	if (m_groups.isEmpty())
+	{
+		verticalScrollBar()->setRange(0, 0);
+	}
+	else
+	{
+		int totalHeight = 0;
+		// top margin
+		totalHeight += m_categoryMargin;
+		int itemScroll = 0;
+		for (auto category : m_groups)
+		{
+			category->m_verticalPosition = totalHeight;
+			totalHeight += category->totalHeight() + m_categoryMargin;
+			if(!itemScroll && category->totalHeight() != 0)
+			{
+				itemScroll = category->contentHeight() / category->numRows();
+			}
+		}
+		// do not divide by zero
+		if(itemScroll == 0)
+			itemScroll = 64;
+
+		totalHeight += m_bottomMargin;
+		verticalScrollBar()->setSingleStep ( itemScroll );
+		const int rowsPerPage = qMax ( viewport()->height() / itemScroll, 1 );
+		verticalScrollBar()->setPageStep ( rowsPerPage * itemScroll );
+
+		verticalScrollBar()->setRange(0, totalHeight - height());
+	}
+
+	verticalScrollBar()->setValue(qMin(previousScroll, verticalScrollBar()->maximum()));
+
+	viewport()->update();
+}
+
+void GroupView::modelReset()
+{
+	scheduleDelayedItemsLayout();
+	executeDelayedItemsLayout();
+}
+
+bool GroupView::isIndexHidden(const QModelIndex &index) const
+{
+	VisualGroup *cat = category(index);
+	if (cat)
+	{
+		return cat->collapsed;
+	}
+	else
+	{
+		return false;
+	}
+}
+
+VisualGroup *GroupView::category(const QModelIndex &index) const
+{
+	return category(index.data(GroupViewRoles::GroupRole).toString());
+}
+
+VisualGroup *GroupView::category(const QString &cat) const
+{
+	for (auto group : m_groups)
+	{
+		if (group->text == cat)
+		{
+			return group;
+		}
+	}
+	return nullptr;
+}
+
+VisualGroup *GroupView::categoryAt(const QPoint &pos) const
+{
+	for (auto group : m_groups)
+	{
+		if(group->hitScan(pos) & VisualGroup::CheckboxHit)
+		{
+			return group;
+		}
+	}
+	return nullptr;
+}
+
+int GroupView::calculateItemsPerRow() const
+{
+	return qFloor((qreal)(contentWidth()) / (qreal)(itemWidth() + m_spacing));
+}
+
+int GroupView::contentWidth() const
+{
+	return width() - m_leftMargin - m_rightMargin;
+}
+
+int GroupView::itemWidth() const
+{
+	return m_itemWidth;
+}
+
+void GroupView::mousePressEvent(QMouseEvent *event)
+{
+	// endCategoryEditor();
+
+	QPoint visualPos = event->pos();
+	QPoint geometryPos = event->pos() + offset();
+	
+	QPersistentModelIndex index = indexAt(visualPos);
+
+	m_pressedIndex = index;
+	m_pressedAlreadySelected = selectionModel()->isSelected(m_pressedIndex);
+	m_pressedPosition = geometryPos;
+
+	m_pressedCategory = categoryAt(geometryPos);
+	if (m_pressedCategory)
+	{
+		setState(m_pressedCategory->collapsed ? ExpandingState : CollapsingState);
+		event->accept();
+		return;
+	}
+
+	if (index.isValid() && (index.flags() & Qt::ItemIsEnabled))
+	{
+		if(index != currentIndex())
+		{
+			// FIXME: better!
+			m_currentCursorColumn = -1;
+		}
+		// we disable scrollTo for mouse press so the item doesn't change position
+		// when the user is interacting with it (ie. clicking on it)
+		bool autoScroll = hasAutoScroll();
+		setAutoScroll(false);
+		selectionModel()->setCurrentIndex(index, QItemSelectionModel::NoUpdate);
+
+		setAutoScroll(autoScroll);
+		QRect rect(visualPos, visualPos);
+		setSelection(rect, QItemSelectionModel::ClearAndSelect);
+
+		// signal handlers may change the model
+		emit pressed(index);
+	}
+	else
+	{
+		// Forces a finalize() even if mouse is pressed, but not on a item
+		selectionModel()->select(QModelIndex(), QItemSelectionModel::Select);
+	}
+}
+
+void GroupView::mouseMoveEvent(QMouseEvent *event)
+{
+	QPoint topLeft;
+	QPoint visualPos = event->pos();
+	QPoint geometryPos = event->pos() + offset();
+
+	if (state() == ExpandingState || state() == CollapsingState)
+	{
+		return;
+	}
+
+	if (state() == DraggingState)
+	{
+		topLeft = m_pressedPosition - offset();
+		if ((topLeft - event->pos()).manhattanLength() > QApplication::startDragDistance())
+		{
+			m_pressedIndex = QModelIndex();
+			startDrag(model()->supportedDragActions());
+			setState(NoState);
+			stopAutoScroll();
+		}
+		return;
+	}
+
+	if (selectionMode() != SingleSelection)
+	{
+		topLeft = m_pressedPosition - offset();
+	}
+	else
+	{
+		topLeft = geometryPos;
+	}
+
+	if (m_pressedIndex.isValid() && (state() != DragSelectingState) &&
+		(event->buttons() != Qt::NoButton) && !selectedIndexes().isEmpty())
+	{
+		setState(DraggingState);
+		return;
+	}
+
+	if ((event->buttons() & Qt::LeftButton) && selectionModel())
+	{
+		setState(DragSelectingState);
+
+		setSelection(QRect(visualPos, visualPos), QItemSelectionModel::ClearAndSelect);
+		QModelIndex index = indexAt(visualPos);
+
+		// set at the end because it might scroll the view
+		if (index.isValid() && (index != selectionModel()->currentIndex()) &&
+			(index.flags() & Qt::ItemIsEnabled))
+		{
+			selectionModel()->setCurrentIndex(index, QItemSelectionModel::NoUpdate);
+		}
+	}
+}
+
+void GroupView::mouseReleaseEvent(QMouseEvent *event)
+{
+	QPoint visualPos = event->pos();
+	QPoint geometryPos = event->pos() + offset();
+	QPersistentModelIndex index = indexAt(visualPos);
+
+	bool click = (index == m_pressedIndex && index.isValid()) ||
+				 (m_pressedCategory && m_pressedCategory == categoryAt(geometryPos));
+
+	if (click && m_pressedCategory)
+	{
+		if (state() == ExpandingState)
+		{
+			m_pressedCategory->collapsed = false;
+			updateGeometries();
+			viewport()->update();
+			event->accept();
+			return;
+		}
+		else if (state() == CollapsingState)
+		{
+			m_pressedCategory->collapsed = true;
+			updateGeometries();
+			viewport()->update();
+			event->accept();
+			return;
+		}
+	}
+
+	m_ctrlDragSelectionFlag = QItemSelectionModel::NoUpdate;
+
+	setState(NoState);
+
+	if (click)
+	{
+		if (event->button() == Qt::LeftButton)
+		{
+			emit clicked(index);
+		}
+		QStyleOptionViewItem option = viewOptions();
+		if (m_pressedAlreadySelected)
+		{
+			option.state |= QStyle::State_Selected;
+		}
+		if ((model()->flags(index) & Qt::ItemIsEnabled) &&
+			style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick, &option, this))
+		{
+			emit activated(index);
+		}
+	}
+}
+
+void GroupView::mouseDoubleClickEvent(QMouseEvent *event)
+{
+	QModelIndex index = indexAt(event->pos());
+	if (!index.isValid() || !(index.flags() & Qt::ItemIsEnabled) || (m_pressedIndex != index))
+	{
+		QMouseEvent me(QEvent::MouseButtonPress, event->localPos(), event->windowPos(),
+					   event->screenPos(), event->button(), event->buttons(),
+					   event->modifiers());
+		mousePressEvent(&me);
+		return;
+	}
+	// signal handlers may change the model
+	QPersistentModelIndex persistent = index;
+	emit doubleClicked(persistent);
+}
+
+void GroupView::paintEvent(QPaintEvent *event)
+{
+	executeDelayedItemsLayout();
+
+	QPainter painter(this->viewport());
+
+	QStyleOptionViewItemV4 option(viewOptions());
+	option.widget = this;
+
+	int wpWidth = viewport()->width();
+	option.rect.setWidth(wpWidth);
+	for (int i = 0; i < m_groups.size(); ++i)
+	{
+		VisualGroup *category = m_groups.at(i);
+		int y = category->verticalPosition();
+		y -= verticalOffset();
+		QRect backup = option.rect;
+		int height = category->totalHeight();
+		option.rect.setTop(y);
+		option.rect.setHeight(height);
+		option.rect.setLeft(m_leftMargin);
+		option.rect.setRight(wpWidth - m_rightMargin);
+		category->drawHeader(&painter, option);
+		y += category->totalHeight() + m_categoryMargin;
+		option.rect = backup;
+	}
+
+	for (int i = 0; i < model()->rowCount(); ++i)
+	{
+		const QModelIndex index = model()->index(i, 0);
+		if (isIndexHidden(index))
+		{
+			continue;
+		}
+		Qt::ItemFlags flags = index.flags();
+		option.rect = visualRect(index);
+		option.features |=
+			QStyleOptionViewItemV2::WrapText; // FIXME: what is the meaning of this anyway?
+		if (flags & Qt::ItemIsSelectable && selectionModel()->isSelected(index))
+		{
+			option.state |= selectionModel()->isSelected(index) ? QStyle::State_Selected
+																: QStyle::State_None;
+		}
+		else
+		{
+			option.state &= ~QStyle::State_Selected;
+		}
+		option.state |= (index == currentIndex()) ? QStyle::State_HasFocus : QStyle::State_None;
+		if (!(flags & Qt::ItemIsEnabled))
+		{
+			option.state &= ~QStyle::State_Enabled;
+		}
+		itemDelegate()->paint(&painter, option, index);
+	}
+
+	/*
+	 * Drop indicators for manual reordering...
+	 */
+#if 0
+	if (!m_lastDragPosition.isNull())
+	{
+		QPair<Group *, int> pair = rowDropPos(m_lastDragPosition);
+		Group *category = pair.first;
+		int row = pair.second;
+		if (category)
+		{
+			int internalRow = row - category->firstItemIndex;
+			QLine line;
+			if (internalRow >= category->numItems())
+			{
+				QRect toTheRightOfRect = visualRect(category->lastItem());
+				line = QLine(toTheRightOfRect.topRight(), toTheRightOfRect.bottomRight());
+			}
+			else
+			{
+				QRect toTheLeftOfRect = visualRect(model()->index(row, 0));
+				line = QLine(toTheLeftOfRect.topLeft(), toTheLeftOfRect.bottomLeft());
+			}
+			painter.save();
+			painter.setPen(QPen(Qt::black, 3));
+			painter.drawLine(line);
+			painter.restore();
+		}
+	}
+#endif
+}
+
+void GroupView::resizeEvent(QResizeEvent *event)
+{
+	int newItemsPerRow = calculateItemsPerRow();
+	if(newItemsPerRow != m_currentItemsPerRow)
+	{
+		m_currentCursorColumn = -1;
+		m_currentItemsPerRow = newItemsPerRow;
+		updateGeometries();
+	}
+}
+
+void GroupView::dragEnterEvent(QDragEnterEvent *event)
+{
+	if (!isDragEventAccepted(event))
+	{
+		return;
+	}
+	m_lastDragPosition = event->pos() + offset();
+	viewport()->update();
+	event->accept();
+}
+
+void GroupView::dragMoveEvent(QDragMoveEvent *event)
+{
+	if (!isDragEventAccepted(event))
+	{
+		return;
+	}
+	m_lastDragPosition = event->pos() + offset();
+	viewport()->update();
+	event->accept();
+}
+
+void GroupView::dragLeaveEvent(QDragLeaveEvent *event)
+{
+	m_lastDragPosition = QPoint();
+	viewport()->update();
+}
+
+void GroupView::dropEvent(QDropEvent *event)
+{
+	m_lastDragPosition = QPoint();
+
+	stopAutoScroll();
+	setState(NoState);
+
+	if (event->source() != this || !(event->possibleActions() & Qt::MoveAction))
+	{
+		return;
+	}
+
+	QPair<VisualGroup *, int> dropPos = rowDropPos(event->pos() + offset());
+	const VisualGroup *category = dropPos.first;
+	const int row = dropPos.second;
+
+	if (row == -1)
+	{
+		viewport()->update();
+		return;
+	}
+
+	const QString categoryText = category->text;
+	if (model()->dropMimeData(event->mimeData(), Qt::MoveAction, row, 0, QModelIndex()))
+	{
+		model()->setData(model()->index(row, 0), categoryText,
+						 GroupViewRoles::GroupRole);
+		event->setDropAction(Qt::MoveAction);
+		event->accept();
+	}
+	updateGeometries();
+	viewport()->update();
+}
+
+void GroupView::startDrag(Qt::DropActions supportedActions)
+{
+	QModelIndexList indexes = selectionModel()->selectedIndexes();
+	if(indexes.count() == 0)
+		return;
+
+	QMimeData *data = model()->mimeData(indexes);
+	if (!data)
+	{
+		return;
+	}
+	QRect rect;
+	QPixmap pixmap = renderToPixmap(indexes, &rect);
+	//rect.translate(offset());
+	// rect.adjust(horizontalOffset(), verticalOffset(), 0, 0);
+	QDrag *drag = new QDrag(this);
+	drag->setPixmap(pixmap);
+	drag->setMimeData(data);
+	Qt::DropAction defaultDropAction = Qt::IgnoreAction;
+	if (this->defaultDropAction() != Qt::IgnoreAction &&
+		(supportedActions & this->defaultDropAction()))
+	{
+		defaultDropAction = this->defaultDropAction();
+	}
+	if (drag->exec(supportedActions, defaultDropAction) == Qt::MoveAction)
+	{
+		const QItemSelection selection = selectionModel()->selection();
+
+		for (auto it = selection.constBegin(); it != selection.constEnd(); ++it)
+		{
+			QModelIndex parent = (*it).parent();
+			if ((*it).left() != 0)
+			{
+				continue;
+			}
+			if ((*it).right() != (model()->columnCount(parent) - 1))
+			{
+				continue;
+			}
+			int count = (*it).bottom() - (*it).top() + 1;
+			model()->removeRows((*it).top(), count, parent);
+		}
+	}
+}
+
+QRect GroupView::visualRect(const QModelIndex &index) const
+{
+	return geometryRect(index).translated(-offset());
+}
+
+QRect GroupView::geometryRect(const QModelIndex &index) const
+{
+	if (!index.isValid() || isIndexHidden(index) || index.column() > 0)
+	{
+		return QRect();
+	}
+
+	int row = index.row();
+	if(geometryCache.contains(row))
+	{
+		return *geometryCache[row];
+	}
+
+	const VisualGroup *cat = category(index);
+	QPair<int, int> pos = cat->positionOf(index);
+	int x = pos.first;
+	// int y = pos.second;
+
+	QRect out;
+	out.setTop(cat->verticalPosition() + cat->headerHeight() + 5 + cat->rowTopOf(index));
+	out.setLeft(m_spacing + x * (itemWidth() + m_spacing));
+	out.setSize(itemDelegate()->sizeHint(viewOptions(), index));
+	geometryCache.insert(row, new QRect(out));
+	return out;
+}
+
+QModelIndex GroupView::indexAt(const QPoint &point) const
+{
+	for (int i = 0; i < model()->rowCount(); ++i)
+	{
+		QModelIndex index = model()->index(i, 0);
+		if (visualRect(index).contains(point))
+		{
+			return index;
+		}
+	}
+	return QModelIndex();
+}
+
+void GroupView::setSelection(const QRect &rect,
+							 const QItemSelectionModel::SelectionFlags commands)
+{
+	for (int i = 0; i < model()->rowCount(); ++i)
+	{
+		QModelIndex index = model()->index(i, 0);
+		QRect itemRect = visualRect(index);
+		if (itemRect.intersects(rect))
+		{
+			selectionModel()->select(index, commands);
+			update(itemRect.translated(-offset()));
+		}
+	}
+}
+
+QPixmap GroupView::renderToPixmap(const QModelIndexList &indices, QRect *r) const
+{
+	Q_ASSERT(r);
+	auto paintPairs = draggablePaintPairs(indices, r);
+	if (paintPairs.isEmpty())
+	{
+		return QPixmap();
+	}
+	QPixmap pixmap(r->size());
+	pixmap.fill(Qt::transparent);
+	QPainter painter(&pixmap);
+	QStyleOptionViewItem option = viewOptions();
+	option.state |= QStyle::State_Selected;
+	for (int j = 0; j < paintPairs.count(); ++j)
+	{
+		option.rect = paintPairs.at(j).first.translated(-r->topLeft());
+		const QModelIndex &current = paintPairs.at(j).second;
+		itemDelegate()->paint(&painter, option, current);
+	}
+	return pixmap;
+}
+
+QList<QPair<QRect, QModelIndex>> GroupView::draggablePaintPairs(const QModelIndexList &indices,
+																QRect *r) const
+{
+	Q_ASSERT(r);
+	QRect &rect = *r;
+	QList<QPair<QRect, QModelIndex>> ret;
+	for (int i = 0; i < indices.count(); ++i)
+	{
+		const QModelIndex &index = indices.at(i);
+		const QRect current = geometryRect(index);
+		ret += qMakePair(current, index);
+		rect |= current;
+	}
+	return ret;
+}
+
+bool GroupView::isDragEventAccepted(QDropEvent *event)
+{
+	return false;
+}
+
+QPair<VisualGroup *, int> GroupView::rowDropPos(const QPoint &pos)
+{
+	return qMakePair<VisualGroup*, int>(nullptr, -1);
+	// FIXME: PIXIE DUST.
+	/*
+	// check that we aren't on a category header and calculate which category we're in
+	VisualGroup *category = 0;
+	{
+		int y = 0;
+		for (auto cat : m_groups)
+		{
+			if (pos.y() > y && pos.y() < (y + cat->headerHeight()))
+			{
+				return qMakePair<VisualGroup*, int>(nullptr, -1);
+			}
+			y += cat->totalHeight() + m_categoryMargin;
+			if (pos.y() < y)
+			{
+				category = cat;
+				break;
+			}
+		}
+		if (category == 0)
+		{
+			return qMakePair<VisualGroup*, int>(nullptr, -1);
+		}
+	}
+
+	QList<QModelIndex> indices = category->items();
+
+	// calculate the internal column
+	int internalColumn = -1;
+	{
+		const int itemWidth = this->itemWidth();
+		if (pos.x() >= (itemWidth * itemsPerRow()))
+		{
+			internalColumn = itemsPerRow();
+		}
+		else
+		{
+			for (int i = 0, c = 0; i < contentWidth(); i += itemWidth + 10 , ++c)
+			{
+				if (pos.x() > (i - itemWidth / 2) && pos.x() <= (i + itemWidth / 2))
+				{
+					internalColumn = c;
+					break;
+				}
+			}
+		}
+		if (internalColumn == -1)
+		{
+			return qMakePair<VisualGroup*, int>(nullptr, -1);
+		}
+	}
+
+	// calculate the internal row
+	int internalRow = -1;
+	{
+		// FIXME rework the drag and drop code
+		const int top = category->verticalPosition();
+		for (int r = 0, h = top; r < category->numRows();
+			 h += itemHeightForCategoryRow(category, r), ++r)
+		{
+			if (pos.y() > h && pos.y() < (h + itemHeightForCategoryRow(category, r)))
+			{
+				internalRow = r;
+				break;
+			}
+		}
+		if (internalRow == -1)
+		{
+			return qMakePair<VisualGroup*, int>(nullptr, -1);
+		}
+		// this happens if we're in the margin between a one category and another
+		// categories header
+		if (internalRow > (indices.size() / itemsPerRow()))
+		{
+			return qMakePair<VisualGroup*, int>(nullptr, -1);
+		}
+	}
+
+	// flaten the internalColumn/internalRow to one row
+	int categoryRow = internalRow * itemsPerRow() + internalColumn;
+
+	// this is used if we're past the last item
+	if (categoryRow >= indices.size())
+	{
+		return qMakePair(category, indices.last().row() + 1);
+	}
+
+	return qMakePair(category, indices.at(categoryRow).row());
+	*/
+}
+
+QPoint GroupView::offset() const
+{
+	return QPoint(horizontalOffset(), verticalOffset());
+}
+
+QRegion GroupView::visualRegionForSelection(const QItemSelection &selection) const
+{
+	QRegion region;
+	for (auto &range : selection)
+	{
+		int start_row = range.top();
+		int end_row = range.bottom();
+		for (int row = start_row; row <= end_row; ++row)
+		{
+			int start_column = range.left();
+			int end_column = range.right();
+			for (int column = start_column; column <= end_column; ++column)
+			{
+				QModelIndex index = model()->index(row, column, rootIndex());
+				region += visualRect(index); // OK
+			}
+		}
+	}
+	return region;
+}
+
+QModelIndex GroupView::moveCursor(QAbstractItemView::CursorAction cursorAction,
+								  Qt::KeyboardModifiers modifiers)
+{
+	auto current = currentIndex();
+	if(!current.isValid())
+	{
+		return current;
+	}
+	auto cat = category(current);
+	int group_index = m_groups.indexOf(cat);
+	if(group_index < 0)
+		return current;
+
+	auto real_group = m_groups[group_index];
+	int beginning_row = 0;
+	for(auto group: m_groups)
+	{
+		if(group == real_group)
+			break;
+		beginning_row += group->numRows();
+	}
+
+	QPair<int, int> pos = cat->positionOf(current);
+	int column = pos.first;
+	int row = pos.second;
+	if(m_currentCursorColumn < 0)
+	{
+		m_currentCursorColumn = column;
+	}
+	switch(cursorAction)
+	{
+		case MoveUp:
+		{
+			if(row == 0)
+			{
+				int prevgroupindex = group_index-1;
+				while(prevgroupindex >= 0)
+				{
+					auto prevgroup = m_groups[prevgroupindex];
+					if(prevgroup->collapsed)
+					{
+						prevgroupindex--;
+						continue;
+					}
+					int newRow = prevgroup->numRows() - 1;
+					int newRowSize = prevgroup->rows[newRow].size();
+					int newColumn = m_currentCursorColumn;
+					if (m_currentCursorColumn >= newRowSize)
+					{
+						newColumn = newRowSize - 1;
+					}
+					return prevgroup->rows[newRow][newColumn];
+				}
+			}
+			else
+			{
+				int newRow = row - 1;
+				int newRowSize = cat->rows[newRow].size();
+				int newColumn = m_currentCursorColumn;
+				if (m_currentCursorColumn >= newRowSize)
+				{
+					newColumn = newRowSize - 1;
+				}
+				return cat->rows[newRow][newColumn];
+			}
+			return current;
+		}
+		case MoveDown:
+		{
+			if(row == cat->rows.size() - 1)
+			{
+				int nextgroupindex = group_index+1;
+				while (nextgroupindex < m_groups.size())
+				{
+					auto nextgroup = m_groups[nextgroupindex];
+					if(nextgroup->collapsed)
+					{
+						nextgroupindex++;
+						continue;
+					}
+					int newRowSize = nextgroup->rows[0].size();
+					int newColumn = m_currentCursorColumn;
+					if (m_currentCursorColumn >= newRowSize)
+					{
+						newColumn = newRowSize - 1;
+					}
+					return nextgroup->rows[0][newColumn];
+				}
+			}
+			else
+			{
+				int newRow = row + 1;
+				int newRowSize = cat->rows[newRow].size();
+				int newColumn = m_currentCursorColumn;
+				if (m_currentCursorColumn >= newRowSize)
+				{
+					newColumn = newRowSize - 1;
+				}
+				return cat->rows[newRow][newColumn];
+			}
+			return current;
+		}
+		case MoveLeft:
+		{
+			if(column > 0)
+			{
+				m_currentCursorColumn = column - 1;
+				return cat->rows[row][column - 1];
+			}
+			// TODO: moving to previous line
+			return current;
+		}
+		case MoveRight:
+		{
+			if(column < cat->rows[row].size() - 1)
+			{
+				m_currentCursorColumn = column + 1;
+				return cat->rows[row][column + 1];
+			}
+			// TODO: moving to next line
+			return current;
+		}
+		case MoveHome:
+		{
+			m_currentCursorColumn = 0;
+			return cat->rows[row][0];
+		}
+		case MoveEnd:
+		{
+			auto last = cat->rows[row].size() - 1;
+			m_currentCursorColumn = last;
+			return cat->rows[row][last];
+		}
+		default:
+			break;
+	}
+	return current;
+}
+
+int GroupView::horizontalOffset() const
+{
+	return horizontalScrollBar()->value();
+}
+
+int GroupView::verticalOffset() const
+{
+	return verticalScrollBar()->value();
+}
+
+void GroupView::scrollContentsBy(int dx, int dy)
+{
+	scrollDirtyRegion(dx, dy);
+	viewport()->scroll(dx, dy);
+}
+
+void GroupView::scrollTo(const QModelIndex &index, ScrollHint hint)
+{
+	if (!index.isValid())
+		return;
+
+	const QRect rect = visualRect(index);
+	if (hint == EnsureVisible && viewport()->rect().contains(rect))
+	{
+		viewport()->update(rect);
+		return;
+	}
+
+	verticalScrollBar()->setValue(verticalScrollToValue(index, rect, hint));
+}
+
+int GroupView::verticalScrollToValue(const QModelIndex &index, const QRect &rect,
+                                            QListView::ScrollHint hint) const
+{
+	const QRect area = viewport()->rect();
+	const bool above = (hint == QListView::EnsureVisible && rect.top() < area.top());
+	const bool below = (hint == QListView::EnsureVisible && rect.bottom() > area.bottom());
+
+	int verticalValue = verticalScrollBar()->value();
+	QRect adjusted = rect.adjusted(-spacing(), -spacing(), spacing(), spacing());
+	if (hint == QListView::PositionAtTop || above)
+		verticalValue += adjusted.top();
+	else if (hint == QListView::PositionAtBottom || below)
+		verticalValue += qMin(adjusted.top(), adjusted.bottom() - area.height() + 1);
+	else if (hint == QListView::PositionAtCenter)
+		verticalValue += adjusted.top() - ((area.height() - adjusted.height()) / 2);
+	return verticalValue;
+}
diff --git a/application/groupview/GroupView.h b/application/groupview/GroupView.h
new file mode 100644
index 00000000..93e45ed7
--- /dev/null
+++ b/application/groupview/GroupView.h
@@ -0,0 +1,125 @@
+#pragma once
+
+#include <QListView>
+#include <QLineEdit>
+#include <QScrollBar>
+#include <QCache>
+
+struct GroupViewRoles
+{
+	enum
+	{
+		GroupRole = Qt::UserRole,
+		ProgressValueRole,
+		ProgressMaximumRole
+	};
+};
+
+struct VisualGroup;
+
+class GroupView : public QAbstractItemView
+{
+	Q_OBJECT
+
+public:
+	GroupView(QWidget *parent = 0);
+	~GroupView();
+
+	void setModel(QAbstractItemModel *model) override;
+
+	/// return geometry rectangle occupied by the specified model item
+	QRect geometryRect(const QModelIndex &index) const;
+	/// return visual rectangle occupied by the specified model item
+	virtual QRect visualRect(const QModelIndex &index) const override;
+	/// get the model index at the specified visual point
+	virtual QModelIndex indexAt(const QPoint &point) const override;
+	void setSelection(const QRect &rect,
+					  const QItemSelectionModel::SelectionFlags commands) override;
+
+	virtual int horizontalOffset() const override;
+	virtual int verticalOffset() const override;
+	virtual void scrollContentsBy(int dx, int dy) override;
+	virtual void scrollTo(const QModelIndex &index, ScrollHint hint = EnsureVisible) override;
+
+	virtual QModelIndex moveCursor(CursorAction cursorAction,
+								   Qt::KeyboardModifiers modifiers) override;
+
+	virtual QRegion visualRegionForSelection(const QItemSelection &selection) const override;
+
+	int spacing() const
+	{
+		return m_spacing;
+	};
+protected
+slots:
+	virtual void dataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight,
+							 const QVector<int> &roles) override;
+	virtual void rowsInserted(const QModelIndex &parent, int start, int end) override;
+	virtual void rowsAboutToBeRemoved(const QModelIndex &parent, int start, int end) override;
+	virtual void updateGeometries() override;
+	void modelReset();
+
+protected:
+	virtual bool isIndexHidden(const QModelIndex &index) const override;
+	void mousePressEvent(QMouseEvent *event) override;
+	void mouseMoveEvent(QMouseEvent *event) override;
+	void mouseReleaseEvent(QMouseEvent *event) override;
+	void mouseDoubleClickEvent(QMouseEvent *event) override;
+	void paintEvent(QPaintEvent *event) override;
+	void resizeEvent(QResizeEvent *event) override;
+
+	void dragEnterEvent(QDragEnterEvent *event) override;
+	void dragMoveEvent(QDragMoveEvent *event) override;
+	void dragLeaveEvent(QDragLeaveEvent *event) override;
+	void dropEvent(QDropEvent *event) override;
+
+	void startDrag(Qt::DropActions supportedActions) override;
+
+private:
+	friend struct VisualGroup;
+	QList<VisualGroup *> m_groups;
+
+	// geometry
+	int m_leftMargin = 5;
+	int m_rightMargin = 5;
+	int m_bottomMargin = 5;
+	int m_categoryMargin = 5;
+	int m_spacing = 5;
+	int m_itemWidth = 100;
+	int m_currentItemsPerRow = -1;
+	int m_currentCursorColumn= -1;
+	mutable QCache<int, QRect> geometryCache;
+
+	// point where the currently active mouse action started in geometry coordinates
+	QPoint m_pressedPosition;
+	QPersistentModelIndex m_pressedIndex;
+	bool m_pressedAlreadySelected;
+	VisualGroup *m_pressedCategory;
+	QItemSelectionModel::SelectionFlag m_ctrlDragSelectionFlag;
+	QPoint m_lastDragPosition;
+
+	VisualGroup *category(const QModelIndex &index) const;
+	VisualGroup *category(const QString &cat) const;
+	VisualGroup *categoryAt(const QPoint &pos) const;
+
+	int itemsPerRow() const
+	{
+		return m_currentItemsPerRow;
+	};
+	int contentWidth() const;
+
+private: /* methods */
+	int itemWidth() const;
+	int calculateItemsPerRow() const;
+	int verticalScrollToValue(const QModelIndex &index, const QRect &rect,
+							  QListView::ScrollHint hint) const;
+	QPixmap renderToPixmap(const QModelIndexList &indices, QRect *r) const;
+	QList<QPair<QRect, QModelIndex>> draggablePaintPairs(const QModelIndexList &indices,
+														 QRect *r) const;
+
+	bool isDragEventAccepted(QDropEvent *event);
+
+	QPair<VisualGroup *, int> rowDropPos(const QPoint &pos);
+
+	QPoint offset() const;
+};
diff --git a/application/groupview/GroupedProxyModel.cpp b/application/groupview/GroupedProxyModel.cpp
new file mode 100644
index 00000000..a45c5ae9
--- /dev/null
+++ b/application/groupview/GroupedProxyModel.cpp
@@ -0,0 +1,42 @@
+#include "GroupedProxyModel.h"
+
+#include "GroupView.h"
+#include <QDebug>
+
+GroupedProxyModel::GroupedProxyModel(QObject *parent) : QSortFilterProxyModel(parent)
+{
+}
+
+bool GroupedProxyModel::lessThan(const QModelIndex &left, const QModelIndex &right) const
+{
+	const QString leftCategory = left.data(GroupViewRoles::GroupRole).toString();
+	const QString rightCategory = right.data(GroupViewRoles::GroupRole).toString();
+	if (leftCategory == rightCategory)
+	{
+		return subSortLessThan(left, right);
+	}
+	else
+	{
+		// FIXME: real group sorting happens in GroupView::updateGeometries(), see LocaleString
+		auto result = leftCategory.localeAwareCompare(rightCategory);
+		if(result < 0)
+		{
+			qDebug() << leftCategory << "<" << rightCategory;
+		}
+		if(result == 0)
+		{
+			qDebug() << leftCategory << "=" << rightCategory;
+			return subSortLessThan(left, right);
+		}
+		if(result > 0)
+		{
+			qDebug() << leftCategory << ">" << rightCategory;
+		}
+		return result < 0;
+	}
+}
+
+bool GroupedProxyModel::subSortLessThan(const QModelIndex &left, const QModelIndex &right) const
+{
+	return left.row() < right.row();
+}
diff --git a/application/groupview/GroupedProxyModel.h b/application/groupview/GroupedProxyModel.h
new file mode 100644
index 00000000..12edee0f
--- /dev/null
+++ b/application/groupview/GroupedProxyModel.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <QSortFilterProxyModel>
+
+class GroupedProxyModel : public QSortFilterProxyModel
+{
+	Q_OBJECT
+
+public:
+	GroupedProxyModel(QObject *parent = 0);
+
+protected:
+	virtual bool lessThan(const QModelIndex &left, const QModelIndex &right) const override;
+	virtual bool subSortLessThan(const QModelIndex &left, const QModelIndex &right) const;
+};
diff --git a/application/groupview/InstanceDelegate.cpp b/application/groupview/InstanceDelegate.cpp
new file mode 100644
index 00000000..b9ad353c
--- /dev/null
+++ b/application/groupview/InstanceDelegate.cpp
@@ -0,0 +1,362 @@
+/* Copyright 2013-2015 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "InstanceDelegate.h"
+#include <QPainter>
+#include <QTextOption>
+#include <QTextLayout>
+#include <QApplication>
+#include <QtMath>
+
+#include "GroupView.h"
+#include "BaseInstance.h"
+#include "InstanceList.h"
+
+QCache<QString, QPixmap> ListViewDelegate::m_pixmapCache;
+
+// Origin: Qt
+static void viewItemTextLayout(QTextLayout &textLayout, int lineWidth, qreal &height,
+							   qreal &widthUsed)
+{
+	height = 0;
+	widthUsed = 0;
+	textLayout.beginLayout();
+	QString str = textLayout.text();
+	while (true)
+	{
+		QTextLine line = textLayout.createLine();
+		if (!line.isValid())
+			break;
+		if (line.textLength() == 0)
+			break;
+		line.setLineWidth(lineWidth);
+		line.setPosition(QPointF(0, height));
+		height += line.height();
+		widthUsed = qMax(widthUsed, line.naturalTextWidth());
+	}
+	textLayout.endLayout();
+}
+
+ListViewDelegate::ListViewDelegate(QObject *parent) : QStyledItemDelegate(parent)
+{
+}
+
+void drawSelectionRect(QPainter *painter, const QStyleOptionViewItemV4 &option,
+					   const QRect &rect)
+{
+	if ((option.state & QStyle::State_Selected))
+		painter->fillRect(rect, option.palette.brush(QPalette::Highlight));
+	else
+	{
+		QColor backgroundColor = option.palette.color(QPalette::Background);
+		backgroundColor.setAlpha(160);
+		painter->fillRect(rect, QBrush(backgroundColor));
+	}
+}
+
+void drawFocusRect(QPainter *painter, const QStyleOptionViewItemV4 &option, const QRect &rect)
+{
+	if (!(option.state & QStyle::State_HasFocus))
+		return;
+	QStyleOptionFocusRect opt;
+	opt.direction = option.direction;
+	opt.fontMetrics = option.fontMetrics;
+	opt.palette = option.palette;
+	opt.rect = rect;
+	// opt.state           = option.state | QStyle::State_KeyboardFocusChange |
+	// QStyle::State_Item;
+	auto col = option.state & QStyle::State_Selected ? QPalette::Highlight : QPalette::Base;
+	opt.backgroundColor = option.palette.color(col);
+	// Apparently some widget styles expect this hint to not be set
+	painter->setRenderHint(QPainter::Antialiasing, false);
+
+	QStyle *style = option.widget ? option.widget->style() : QApplication::style();
+
+	style->drawPrimitive(QStyle::PE_FrameFocusRect, &opt, painter, option.widget);
+
+	painter->setRenderHint(QPainter::Antialiasing);
+}
+
+// TODO this can be made a lot prettier
+void drawProgressOverlay(QPainter *painter, const QStyleOptionViewItemV4 &option,
+						 const int value, const int maximum)
+{
+	if (maximum == 0 || value == maximum)
+	{
+		return;
+	}
+
+	painter->save();
+
+	qreal percent = (qreal)value / (qreal)maximum;
+	QColor color = option.palette.color(QPalette::Dark);
+	color.setAlphaF(0.70f);
+	painter->setBrush(color);
+	painter->setPen(QPen(QBrush(), 0));
+	painter->drawPie(option.rect, 90 * 16, -percent * 360 * 16);
+
+	painter->restore();
+}
+
+void drawBadges(QPainter *painter, const QStyleOptionViewItemV4 &option, BaseInstance *instance)
+{
+	QList<QString> pixmaps;
+	const BaseInstance::InstanceFlags flags = instance->flags();
+	if (flags & BaseInstance::VersionBrokenFlag)
+	{
+		pixmaps.append("broken");
+	}
+	if (flags & BaseInstance::UpdateAvailable)
+	{
+		pixmaps.append("updateavailable");
+	}
+
+	// begin easter eggs
+	if (instance->name().contains("btw", Qt::CaseInsensitive) ||
+		instance->name().contains("better then wolves", Qt::CaseInsensitive) ||
+		instance->name().contains("better than wolves", Qt::CaseInsensitive))
+	{
+		pixmaps.append("herobrine");
+	}
+	if (instance->name().contains("direwolf", Qt::CaseInsensitive))
+	{
+		pixmaps.append("enderman");
+	}
+	if (instance->name().contains("kitten", Qt::CaseInsensitive))
+	{
+		pixmaps.append("kitten");
+	}
+	if (instance->name().contains("derp", Qt::CaseInsensitive))
+	{
+		pixmaps.append("derp");
+	}
+	// end easter eggs
+
+	static const int itemSide = 24;
+	static const int spacing = 1;
+	const int itemsPerRow = qMax(1, qFloor(double(option.rect.width() + spacing) / double(itemSide + spacing)));
+	const int rows = qCeil((double)pixmaps.size() / (double)itemsPerRow);
+	QListIterator<QString> it(pixmaps);
+	painter->translate(option.rect.topLeft());
+	for (int y = 0; y < rows; ++y)
+	{
+		for (int x = 0; x < itemsPerRow; ++x)
+		{
+			if (!it.hasNext())
+			{
+				return;
+			}
+			const QPixmap pixmap = ListViewDelegate::requestBadgePixmap(it.next()).scaled(
+				itemSide, itemSide, Qt::KeepAspectRatio, Qt::FastTransformation);
+			painter->drawPixmap(option.rect.width() - x * itemSide + qMax(x - 1, 0) * spacing - itemSide,
+								y * itemSide + qMax(y - 1, 0) * spacing, itemSide, itemSide,
+								pixmap);
+		}
+	}
+	painter->translate(-option.rect.topLeft());
+}
+
+static QSize viewItemTextSize(const QStyleOptionViewItemV4 *option)
+{
+	QStyle *style = option->widget ? option->widget->style() : QApplication::style();
+	QTextOption textOption;
+	textOption.setWrapMode(QTextOption::WrapAtWordBoundaryOrAnywhere);
+	QTextLayout textLayout;
+	textLayout.setTextOption(textOption);
+	textLayout.setFont(option->font);
+	textLayout.setText(option->text);
+	const int textMargin =
+		style->pixelMetric(QStyle::PM_FocusFrameHMargin, option, option->widget) + 1;
+	QRect bounds(0, 0, 100 - 2 * textMargin, 600);
+	qreal height = 0, widthUsed = 0;
+	viewItemTextLayout(textLayout, bounds.width(), height, widthUsed);
+	const QSize size(qCeil(widthUsed), qCeil(height));
+	return QSize(size.width() + 2 * textMargin, size.height());
+}
+
+void ListViewDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option,
+							 const QModelIndex &index) const
+{
+	QStyleOptionViewItemV4 opt = option;
+	initStyleOption(&opt, index);
+	painter->save();
+	painter->setClipRect(opt.rect);
+
+	opt.features |= QStyleOptionViewItem::WrapText;
+	opt.text = index.data().toString();
+	opt.textElideMode = Qt::ElideRight;
+	opt.displayAlignment = Qt::AlignTop | Qt::AlignHCenter;
+
+	QStyle *style = opt.widget ? opt.widget->style() : QApplication::style();
+
+	// const int iconSize =  style->pixelMetric(QStyle::PM_IconViewIconSize);
+	const int iconSize = 48;
+	QRect iconbox = opt.rect;
+	const int textMargin = style->pixelMetric(QStyle::PM_FocusFrameHMargin, 0, opt.widget) + 1;
+	QRect textRect = opt.rect;
+	QRect textHighlightRect = textRect;
+	// clip the decoration on top, remove width padding
+	textRect.adjust(textMargin, iconSize + textMargin + 5, -textMargin, 0);
+
+	textHighlightRect.adjust(0, iconSize + 5, 0, 0);
+
+	// draw background
+	{
+		// FIXME: unused
+		// QSize textSize = viewItemTextSize ( &opt );
+		QPalette::ColorGroup cg;
+		QStyleOptionViewItemV4 opt2(opt);
+
+		if ((opt.widget && opt.widget->isEnabled()) || (opt.state & QStyle::State_Enabled))
+		{
+			if (!(opt.state & QStyle::State_Active))
+				cg = QPalette::Inactive;
+			else
+				cg = QPalette::Normal;
+		}
+		else
+		{
+			cg = QPalette::Disabled;
+		}
+		opt2.palette.setCurrentColorGroup(cg);
+
+		// fill in background, if any
+
+		if (opt.backgroundBrush.style() != Qt::NoBrush)
+		{
+			QPointF oldBO = painter->brushOrigin();
+			painter->setBrushOrigin(opt.rect.topLeft());
+			painter->fillRect(opt.rect, opt.backgroundBrush);
+			painter->setBrushOrigin(oldBO);
+		}
+
+		drawSelectionRect(painter, opt2, textHighlightRect);
+
+		/*
+		if (opt.showDecorationSelected)
+		{
+			drawSelectionRect(painter, opt2, opt.rect);
+			drawFocusRect(painter, opt2, opt.rect);
+			// painter->fillRect ( opt.rect, opt.palette.brush ( cg, QPalette::Highlight ) );
+		}
+		else
+		{
+
+			// if ( opt.state & QStyle::State_Selected )
+			{
+				// QRect textRect = subElementRect ( QStyle::SE_ItemViewItemText,  opt,
+				// opt.widget );
+				// painter->fillRect ( textHighlightRect, opt.palette.brush ( cg,
+				// QPalette::Highlight ) );
+				drawSelectionRect(painter, opt2, textHighlightRect);
+				drawFocusRect(painter, opt2, textHighlightRect);
+			}
+		}
+		*/
+	}
+
+	// draw the icon
+	{
+		QIcon::Mode mode = QIcon::Normal;
+		if (!(opt.state & QStyle::State_Enabled))
+			mode = QIcon::Disabled;
+		else if (opt.state & QStyle::State_Selected)
+			mode = QIcon::Selected;
+		QIcon::State state = opt.state & QStyle::State_Open ? QIcon::On : QIcon::Off;
+
+		iconbox.setHeight(iconSize);
+		opt.icon.paint(painter, iconbox, Qt::AlignCenter, mode, state);
+	}
+	// set the text colors
+	QPalette::ColorGroup cg =
+		opt.state & QStyle::State_Enabled ? QPalette::Normal : QPalette::Disabled;
+	if (cg == QPalette::Normal && !(opt.state & QStyle::State_Active))
+		cg = QPalette::Inactive;
+	if (opt.state & QStyle::State_Selected)
+	{
+		painter->setPen(opt.palette.color(cg, QPalette::HighlightedText));
+	}
+	else
+	{
+		painter->setPen(opt.palette.color(cg, QPalette::Text));
+	}
+
+	// draw the text
+	QTextOption textOption;
+	textOption.setWrapMode(QTextOption::WrapAtWordBoundaryOrAnywhere);
+	textOption.setTextDirection(opt.direction);
+	textOption.setAlignment(QStyle::visualAlignment(opt.direction, opt.displayAlignment));
+	QTextLayout textLayout;
+	textLayout.setTextOption(textOption);
+	textLayout.setFont(opt.font);
+	textLayout.setText(opt.text);
+
+	qreal width, height;
+	viewItemTextLayout(textLayout, textRect.width(), height, width);
+
+	const int lineCount = textLayout.lineCount();
+
+	const QRect layoutRect = QStyle::alignedRect(
+		opt.direction, opt.displayAlignment, QSize(textRect.width(), int(height)), textRect);
+	const QPointF position = layoutRect.topLeft();
+	for (int i = 0; i < lineCount; ++i)
+	{
+		const QTextLine line = textLayout.lineAt(i);
+		line.draw(painter, position);
+	}
+
+	// FIXME: this really has no business of being here. Make generic.
+	auto instance = (BaseInstance*)index.data(InstanceList::InstancePointerRole)
+			.value<void *>();
+	if (instance)
+	{
+		drawBadges(painter, opt, instance);
+	}
+
+	drawProgressOverlay(painter, opt, index.data(GroupViewRoles::ProgressValueRole).toInt(),
+						index.data(GroupViewRoles::ProgressMaximumRole).toInt());
+
+	painter->restore();
+}
+
+QSize ListViewDelegate::sizeHint(const QStyleOptionViewItem &option,
+								 const QModelIndex &index) const
+{
+	QStyleOptionViewItemV4 opt = option;
+	initStyleOption(&opt, index);
+	opt.features |= QStyleOptionViewItem::WrapText;
+	opt.text = index.data().toString();
+	opt.textElideMode = Qt::ElideRight;
+	opt.displayAlignment = Qt::AlignTop | Qt::AlignHCenter;
+
+	QStyle *style = opt.widget ? opt.widget->style() : QApplication::style();
+	const int textMargin =
+		style->pixelMetric(QStyle::PM_FocusFrameHMargin, &option, opt.widget) + 1;
+	int height = 48 + textMargin * 2 + 5; // TODO: turn constants into variables
+	QSize szz = viewItemTextSize(&opt);
+	height += szz.height();
+	// FIXME: maybe the icon items could scale and keep proportions?
+	QSize sz(100, height);
+	return sz;
+}
+
+QPixmap ListViewDelegate::requestBadgePixmap(const QString &key)
+{
+	if (!m_pixmapCache.contains(key))
+	{
+		m_pixmapCache.insert(key, new QPixmap(":/icons/badges/" + key + ".png"));
+	}
+	return *m_pixmapCache.object(key);
+}
diff --git a/application/groupview/InstanceDelegate.h b/application/groupview/InstanceDelegate.h
new file mode 100644
index 00000000..2b5439cb
--- /dev/null
+++ b/application/groupview/InstanceDelegate.h
@@ -0,0 +1,35 @@
+/* Copyright 2013-2015 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <QStyledItemDelegate>
+#include <QCache>
+
+class ListViewDelegate : public QStyledItemDelegate
+{
+public:
+	explicit ListViewDelegate(QObject *parent = 0);
+
+	static QPixmap requestBadgePixmap(const QString &key);
+
+protected:
+	void paint(QPainter *painter, const QStyleOptionViewItem &option,
+			   const QModelIndex &index) const;
+	QSize sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const;
+
+private:
+	static QCache<QString, QPixmap> m_pixmapCache;
+};
diff --git a/application/groupview/VisualGroup.cpp b/application/groupview/VisualGroup.cpp
new file mode 100644
index 00000000..560fc9ca
--- /dev/null
+++ b/application/groupview/VisualGroup.cpp
@@ -0,0 +1,301 @@
+#include "VisualGroup.h"
+
+#include <QModelIndex>
+#include <QPainter>
+#include <QtMath>
+#include <QApplication>
+
+#include "GroupView.h"
+
+VisualGroup::VisualGroup(const QString &text, GroupView *view) : view(view), text(text), collapsed(false)
+{
+}
+
+VisualGroup::VisualGroup(const VisualGroup *other)
+	: view(other->view), text(other->text), collapsed(other->collapsed)
+{
+}
+
+void VisualGroup::update()
+{
+	auto temp_items = items();
+	auto itemsPerRow = view->itemsPerRow();
+
+	int numRows = qMax(1, qCeil((qreal)temp_items.size() / (qreal)itemsPerRow));
+	rows = QVector<VisualRow>(numRows);
+
+	int maxRowHeight = 0;
+	int positionInRow = 0;
+	int currentRow = 0;
+	int offsetFromTop = 0;
+	for (auto item: temp_items)
+	{
+		if(positionInRow == itemsPerRow)
+		{
+			rows[currentRow].height = maxRowHeight;
+			rows[currentRow].top = offsetFromTop;
+			currentRow ++;
+			offsetFromTop += maxRowHeight + 5;
+			positionInRow = 0;
+			maxRowHeight = 0;
+		}
+		auto itemHeight = view->itemDelegate()->sizeHint(view->viewOptions(), item).height();
+		if(itemHeight > maxRowHeight)
+		{
+			maxRowHeight = itemHeight;
+		}
+		rows[currentRow].items.append(item);
+		positionInRow++;
+	}
+	rows[currentRow].height = maxRowHeight;
+	rows[currentRow].top = offsetFromTop;
+}
+
+QPair<int, int> VisualGroup::positionOf(const QModelIndex &index) const
+{
+	int x = 0;
+	int y = 0;
+	for (auto & row: rows)
+	{
+		for(auto x = 0; x < row.items.size(); x++)
+		{
+			if(row.items[x] == index)
+			{
+				return qMakePair(x,y);
+			}
+		}
+		y++;
+	}
+	return qMakePair(x, y);
+}
+
+int VisualGroup::rowTopOf(const QModelIndex &index) const
+{
+	auto position = positionOf(index);
+	return rows[position.second].top;
+}
+
+int VisualGroup::rowHeightOf(const QModelIndex &index) const
+{
+	auto position = positionOf(index);
+	return rows[position.second].height;
+}
+
+VisualGroup::HitResults VisualGroup::hitScan(const QPoint &pos) const
+{
+	VisualGroup::HitResults results = VisualGroup::NoHit;
+	int y_start = verticalPosition();
+	int body_start = y_start + headerHeight();
+	int body_end = body_start + contentHeight() + 5; // FIXME: wtf is this 5?
+	int y = pos.y();
+	// int x = pos.x();
+	if (y < y_start)
+	{
+		results = VisualGroup::NoHit;
+	}
+	else if (y < body_start)
+	{
+		results = VisualGroup::HeaderHit;
+		int collapseSize = headerHeight() - 4;
+
+		// the icon
+		QRect iconRect = QRect(view->m_leftMargin + 2, 2 + y_start, collapseSize, collapseSize);
+		if (iconRect.contains(pos))
+		{
+			results |= VisualGroup::CheckboxHit;
+		}
+	}
+	else if (y < body_end)
+	{
+		results |= VisualGroup::BodyHit;
+	}
+	return results;
+}
+
+void VisualGroup::drawHeader(QPainter *painter, const QStyleOptionViewItem &option)
+{
+	painter->setRenderHint(QPainter::Antialiasing);
+
+	const QRect optRect = option.rect;
+	QFont font(QApplication::font());
+	font.setBold(true);
+	const QFontMetrics fontMetrics = QFontMetrics(font);
+
+	QColor outlineColor = option.palette.text().color();
+	outlineColor.setAlphaF(0.35);
+
+	//BEGIN: top left corner
+	{
+		painter->save();
+		painter->setPen(outlineColor);
+		const QPointF topLeft(optRect.topLeft());
+		QRectF arc(topLeft, QSizeF(4, 4));
+		arc.translate(0.5, 0.5);
+		painter->drawArc(arc, 1440, 1440);
+		painter->restore();
+	}
+	//END: top left corner
+
+	//BEGIN: left vertical line
+	{
+		QPoint start(optRect.topLeft());
+		start.ry() += 3;
+		QPoint verticalGradBottom(optRect.topLeft());
+		verticalGradBottom.ry() += fontMetrics.height() + 5;
+		QLinearGradient gradient(start, verticalGradBottom);
+		gradient.setColorAt(0, outlineColor);
+		gradient.setColorAt(1, Qt::transparent);
+		painter->fillRect(QRect(start, QSize(1, fontMetrics.height() + 5)), gradient);
+	}
+	//END: left vertical line
+
+	//BEGIN: horizontal line
+	{
+		QPoint start(optRect.topLeft());
+		start.rx() += 3;
+		QPoint horizontalGradTop(optRect.topLeft());
+		horizontalGradTop.rx() += optRect.width() - 6;
+		painter->fillRect(QRect(start, QSize(optRect.width() - 6, 1)), outlineColor);
+	}
+	//END: horizontal line
+
+	//BEGIN: top right corner
+	{
+		painter->save();
+		painter->setPen(outlineColor);
+		QPointF topRight(optRect.topRight());
+		topRight.rx() -= 4;
+		QRectF arc(topRight, QSizeF(4, 4));
+		arc.translate(0.5, 0.5);
+		painter->drawArc(arc, 0, 1440);
+		painter->restore();
+	}
+	//END: top right corner
+
+	//BEGIN: right vertical line
+	{
+		QPoint start(optRect.topRight());
+		start.ry() += 3;
+		QPoint verticalGradBottom(optRect.topRight());
+		verticalGradBottom.ry() += fontMetrics.height() + 5;
+		QLinearGradient gradient(start, verticalGradBottom);
+		gradient.setColorAt(0, outlineColor);
+		gradient.setColorAt(1, Qt::transparent);
+		painter->fillRect(QRect(start, QSize(1, fontMetrics.height() + 5)), gradient);
+	}
+	//END: right vertical line
+
+	//BEGIN: checkboxy thing
+	{
+		painter->save();
+		painter->setRenderHint(QPainter::Antialiasing, false);
+		painter->setFont(font);
+		QColor penColor(option.palette.text().color());
+		penColor.setAlphaF(0.6);
+		painter->setPen(penColor);
+		QRect iconSubRect(option.rect);
+		iconSubRect.setTop(iconSubRect.top() + 7);
+		iconSubRect.setLeft(iconSubRect.left() + 7);
+
+		int sizing = fontMetrics.height();
+		int even = ( (sizing - 1) % 2 );
+
+		iconSubRect.setHeight(sizing - even);
+		iconSubRect.setWidth(sizing - even);
+		painter->drawRect(iconSubRect);
+
+
+		/*
+		if(collapsed)
+			painter->drawText(iconSubRect, Qt::AlignHCenter | Qt::AlignVCenter, "+");
+		else
+			painter->drawText(iconSubRect, Qt::AlignHCenter | Qt::AlignVCenter, "-");
+		*/
+		painter->setBrush(option.palette.text());
+		painter->fillRect(iconSubRect.x(), iconSubRect.y() + iconSubRect.height() / 2,
+						  iconSubRect.width(), 2, penColor);
+		if (collapsed)
+		{
+			painter->fillRect(iconSubRect.x() + iconSubRect.width() / 2, iconSubRect.y(), 2,
+							  iconSubRect.height(), penColor);
+		}
+
+		painter->restore();
+	}
+	//END: checkboxy thing
+
+	//BEGIN: text
+	{
+		QRect textRect(option.rect);
+		textRect.setTop(textRect.top() + 7);
+		textRect.setLeft(textRect.left() + 7 + fontMetrics.height() + 7);
+		textRect.setHeight(fontMetrics.height());
+		textRect.setRight(textRect.right() - 7);
+
+		painter->save();
+		painter->setFont(font);
+		QColor penColor(option.palette.text().color());
+		penColor.setAlphaF(0.6);
+		painter->setPen(penColor);
+		painter->drawText(textRect, Qt::AlignLeft | Qt::AlignVCenter, text);
+		painter->restore();
+	}
+	//END: text
+}
+
+int VisualGroup::totalHeight() const
+{
+	return headerHeight() + 5 + contentHeight(); // FIXME: wtf is that '5'?
+}
+
+int VisualGroup::headerHeight() const
+{
+	QFont font(QApplication::font());
+    font.setBold(true);
+    QFontMetrics fontMetrics(font);
+
+    const int height = fontMetrics.height() + 1 /* 1 pixel-width gradient */
+                                            + 11 /* top and bottom separation */;
+    return height;
+	/*
+	int raw = view->viewport()->fontMetrics().height() + 4;
+	// add english. maybe. depends on font height.
+	if (raw % 2 == 0)
+		raw++;
+	return std::min(raw, 25);
+	*/
+}
+
+int VisualGroup::contentHeight() const
+{
+	if (collapsed)
+	{
+		return 0;
+	}
+	auto last = rows[numRows() - 1];
+	return last.top + last.height;
+}
+
+int VisualGroup::numRows() const
+{
+	return rows.size();
+}
+
+int VisualGroup::verticalPosition() const
+{
+	return m_verticalPosition;
+}
+
+QList<QModelIndex> VisualGroup::items() const
+{
+	QList<QModelIndex> indices;
+	for (int i = 0; i < view->model()->rowCount(); ++i)
+	{
+		const QModelIndex index = view->model()->index(i, 0);
+		if (index.data(GroupViewRoles::GroupRole).toString() == text)
+		{
+			indices.append(index);
+		}
+	}
+	return indices;
+}
diff --git a/application/groupview/VisualGroup.h b/application/groupview/VisualGroup.h
new file mode 100644
index 00000000..d8d1f145
--- /dev/null
+++ b/application/groupview/VisualGroup.h
@@ -0,0 +1,91 @@
+#pragma once
+
+#include <QString>
+#include <QRect>
+#include <QVector>
+#include <QStyleOption>
+
+class GroupView;
+class QPainter;
+class QModelIndex;
+
+struct VisualRow
+{
+	QList<QModelIndex> items;
+	int height = 0;
+	int top = 0;
+	inline int size() const
+	{
+		return items.size();
+	}
+	inline QModelIndex &operator[](int i)
+	{
+		return items[i];
+	}
+};
+
+struct VisualGroup
+{
+/* constructors */
+	VisualGroup(const QString &text, GroupView *view);
+	VisualGroup(const VisualGroup *other);
+
+/* data */
+	GroupView *view = nullptr;
+	QString text;
+	bool collapsed = false;
+	QVector<VisualRow> rows;
+	int firstItemIndex = 0;
+	int m_verticalPosition = 0;
+
+/* logic */
+	/// update the internal list of items and flow them into the rows.
+	void update();
+
+	/// draw the header at y-position.
+	void drawHeader(QPainter *painter, const QStyleOptionViewItem &option);
+
+	/// height of the group, in total. includes a small bit of padding.
+	int totalHeight() const;
+
+	/// height of the group header, in pixels
+	int headerHeight() const;
+
+	/// height of the group content, in pixels
+	int contentHeight() const;
+
+	/// the number of visual rows this group has
+	int numRows() const;
+
+	/// actually calculate the above value
+	int calculateNumRows() const;
+
+	/// the height at which this group starts, in pixels
+	int verticalPosition() const;
+
+	/// relative geometry - top of the row of the given item
+	int rowTopOf(const QModelIndex &index) const;
+
+	/// height of the row of the given item
+	int rowHeightOf(const QModelIndex &index) const;
+
+	/// x/y position of the given item inside the group (in items!)
+	QPair<int, int> positionOf(const QModelIndex &index) const;
+
+	enum HitResult
+	{
+		NoHit = 0x0,
+		TextHit = 0x1,
+		CheckboxHit = 0x2,
+		HeaderHit = 0x4,
+		BodyHit = 0x8
+	};
+	Q_DECLARE_FLAGS(HitResults, HitResult)
+
+	/// shoot! BANG! what did we hit?
+	HitResults hitScan (const QPoint &pos) const;
+
+	QList<QModelIndex> items() const;
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(VisualGroup::HitResults)