[pulseview.git] / pv / view / header.cpp

/*
 * This file is part of the PulseView project.
 *
 * Copyright (C) 2012 Joel Holdsworth <joel@airwebreathe.org.uk>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
 */

#include "header.hpp"
#include "view.hpp"

#include "signal.hpp"
#include "tracegroup.hpp"

#include <cassert>
#include <algorithm>

#include <boost/iterator/filter_iterator.hpp>

#include <QApplication>
#include <QMenu>
#include <QMouseEvent>
#include <QPainter>
#include <QRect>

#include <pv/session.hpp>
#include <pv/widgets/popup.hpp>

using boost::make_filter_iterator;
using std::dynamic_pointer_cast;
using std::max;
using std::make_pair;
using std::min;
using std::pair;
using std::shared_ptr;
using std::stable_sort;
using std::vector;

namespace pv {
namespace view {

const int Header::Padding = 12;
const int Header::BaselineOffset = 5;

static bool item_selected(shared_ptr<RowItem> r)
{
	return r->selected();
}

Header::Header(View &parent) :
	MarginWidget(parent)
{
	connect(&view_, SIGNAL(signals_moved()),
		this, SLOT(on_signals_moved()));
}

QSize Header::sizeHint() const
{
	QRectF max_rect(-Padding, 0, Padding, 0);
	for (auto &i : view_)
		if (i->enabled())
			max_rect = max_rect.united(i->label_rect(QRect()));
	return QSize(max_rect.width() + Padding + BaselineOffset, 0);
}

QSize Header::extended_size_hint() const
{
	return sizeHint() + QSize(ViewItem::HighlightRadius, 0);
}

vector< shared_ptr<ViewItem> > Header::items()
{
	return vector< shared_ptr<ViewItem> >(view_.begin(), view_.end());
}

shared_ptr<ViewItem> Header::get_mouse_over_item(const QPoint &pt)
{
	const QRect r(0, 0, width() - BaselineOffset, height());
	for (auto &i : view_)
		if (i->enabled() && i->label_rect(r).contains(pt))
			return i;
	return shared_ptr<RowItem>();
}

void Header::clear_selection()
{
	for (auto &i : view_)
		i->select(false);
	update();
}

void Header::paintEvent(QPaintEvent*)
{
	// The trace labels are not drawn with the arrows exactly on the
	// left edge of the widget, because then the selection shadow
	// would be clipped away.
	const QRect rect(0, 0, width() - BaselineOffset, height());

	vector< shared_ptr<RowItem> > row_items(
		view_.begin(), view_.end());

	stable_sort(row_items.begin(), row_items.end(),
		[](const shared_ptr<RowItem> &a, const shared_ptr<RowItem> &b) {
			return a->visual_v_offset() < b->visual_v_offset(); });

	QPainter painter(this);
	painter.setRenderHint(QPainter::Antialiasing);

	for (const shared_ptr<RowItem> r : row_items)
	{
		assert(r);

		const bool highlight = !dragging_ &&
			r->label_rect(rect).contains(mouse_point_);
		r->paint_label(painter, rect, highlight);
	}

	painter.end();
}

void Header::mouseLeftPressEvent(QMouseEvent *event)
{
	(void)event;

	const bool ctrl_pressed =
		QApplication::keyboardModifiers() & Qt::ControlModifier;

	// Clear selection if control is not pressed and this item is unselected
	if ((!mouse_down_item_ || !mouse_down_item_->selected()) &&
		!ctrl_pressed)
		for (shared_ptr<RowItem> r : view_)
			r->select(false);

	// Set the signal selection state if the item has been clicked
	if (mouse_down_item_) {
		if (ctrl_pressed)
			mouse_down_item_->select(!mouse_down_item_->selected());
		else
			mouse_down_item_->select(true);
	}

	// Save the offsets of any signals which will be dragged
	for (const shared_ptr<RowItem> r : view_)
		if (r->selected())
			r->drag();

	selection_changed();
	update();
}

void Header::mousePressEvent(QMouseEvent *event)
{
	assert(event);

	mouse_down_point_ = event->pos();
	mouse_down_item_ = get_mouse_over_item(event->pos());

	if (event->button() & Qt::LeftButton)
		mouseLeftPressEvent(event);
}

void Header::mouseLeftReleaseEvent(QMouseEvent *event)
{
	assert(event);

	const bool ctrl_pressed =
		QApplication::keyboardModifiers() & Qt::ControlModifier;

	// Unselect everything if control is not pressed
	const shared_ptr<ViewItem> mouse_over =
		get_mouse_over_item(event->pos());

	for (auto &r : view_)
		r->drag_release();

	if (dragging_)
		view_.restack_all_row_items();
	else
	{
		if (!ctrl_pressed) {
			for (shared_ptr<RowItem> r : view_)
				if (mouse_down_item_ != r)
					r->select(false);

			if (mouse_down_item_)
				show_popup(mouse_down_item_);
		}
	}

	dragging_ = false;
}

void Header::mouseReleaseEvent(QMouseEvent *event)
{
	assert(event);
	if (event->button() & Qt::LeftButton)
		mouseLeftReleaseEvent(event);

	mouse_down_item_ = nullptr;
}

void Header::mouseMoveEvent(QMouseEvent *event)
{
	assert(event);
	mouse_point_ = event->pos();

	if (!(event->buttons() & Qt::LeftButton))
		return;

	if ((event->pos() - mouse_down_point_).manhattanLength() <
		QApplication::startDragDistance())
		return;

	// Check all the drag items share a common owner
	RowItemOwner *item_owner = nullptr;
	for (shared_ptr<RowItem> r : view_)
		if (r->dragging()) {
			if (!item_owner)
				item_owner = r->owner();
			else if(item_owner != r->owner())
				return;
		}

	if (!item_owner)
		return;

	// Do the drag
	dragging_ = true;

	const QPoint delta = event->pos() - mouse_down_point_;

	for (std::shared_ptr<RowItem> r : view_)
		if (r->dragging()) {
			r->drag_by(delta);

			// Ensure the trace is selected
			r->select();
		}

	item_owner->restack_items();
	for (const auto &r : *item_owner)
		r->animate_to_layout_v_offset();
	signals_moved();

	update();
}

void Header::contextMenuEvent(QContextMenuEvent *event)
{
	const shared_ptr<ViewItem> r = get_mouse_over_item(mouse_point_);
	if (!r)
		return;

	QMenu *menu = r->create_context_menu(this);
	if (!menu)
		menu = new QMenu(this);

	if (std::count_if(view_.begin(), view_.end(), item_selected) > 1)
	{
		menu->addSeparator();

		QAction *const group = new QAction(tr("Group"), this);
		QList<QKeySequence> shortcuts;
		shortcuts.append(QKeySequence(Qt::ControlModifier | Qt::Key_G));
		group->setShortcuts(shortcuts);
		connect(group, SIGNAL(triggered()), this, SLOT(on_group()));
		menu->addAction(group);
	}

	menu->exec(event->globalPos());
}

void Header::keyPressEvent(QKeyEvent *e)
{
	assert(e);

	if (e->key() == Qt::Key_Delete)
	{
		for (const shared_ptr<RowItem> r : view_)
			if (r->selected())
				r->delete_pressed();
	}
	else if (e->key() == Qt::Key_G && e->modifiers() == Qt::ControlModifier)
		on_group();
	else if (e->key() == Qt::Key_U && e->modifiers() == Qt::ControlModifier)
		on_ungroup();
}

void Header::on_signals_moved()
{
	update();
}

void Header::on_group()
{
	vector< shared_ptr<RowItem> > selected_items(
		make_filter_iterator(item_selected, view_.begin(), view_.end()),
		make_filter_iterator(item_selected, view_.end(), view_.end()));
	stable_sort(selected_items.begin(), selected_items.end(),
		[](const shared_ptr<RowItem> &a, const shared_ptr<RowItem> &b) {
			return a->visual_v_offset() < b->visual_v_offset(); });

	shared_ptr<TraceGroup> group(new TraceGroup());
	shared_ptr<RowItem> mouse_down_item(
		std::dynamic_pointer_cast<RowItem>(mouse_down_item_));
	shared_ptr<RowItem> focus_item(
		mouse_down_item ? mouse_down_item : selected_items.front());

	assert(focus_item);
	assert(focus_item->owner());
	focus_item->owner()->add_child_item(group);

	// Set the group v_offset here before reparenting
	group->force_to_v_offset(focus_item->layout_v_offset() +
		focus_item->v_extents().first);

	for (size_t i = 0; i < selected_items.size(); i++) {
		const shared_ptr<RowItem> &r = selected_items[i];
		assert(r->owner());
		r->owner()->remove_child_item(r);
		group->add_child_item(r);

		// Put the items at 1-pixel offsets, so that restack will
		// stack them in the right order
		r->set_layout_v_offset(i);
	}
}

void Header::on_ungroup()
{
	bool restart;
	do {
		restart = false;
		for (const shared_ptr<RowItem> r : view_) {
			const shared_ptr<TraceGroup> tg =
				dynamic_pointer_cast<TraceGroup>(r);
			if (tg && tg->selected()) {
				tg->ungroup();
				restart = true;
				break;
			}
		}
	} while(restart);
}

} // namespace view
} // namespace pv
Commit	Line	Data
	1	/*
	2	* This file is part of the PulseView project.
	3	*
	4	* Copyright (C) 2012 Joel Holdsworth <joel@airwebreathe.org.uk>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	19	*/
	20
	21	#include "header.hpp"
	22	#include "view.hpp"
	23
	24	#include "signal.hpp"
	25	#include "tracegroup.hpp"
	26
	27	#include <cassert>
	28	#include <algorithm>
	29
	30	#include <boost/iterator/filter_iterator.hpp>
	31
	32	#include <QApplication>
	33	#include <QMenu>
	34	#include <QMouseEvent>
	35	#include <QPainter>
	36	#include <QRect>
	37
	38	#include <pv/session.hpp>
	39	#include <pv/widgets/popup.hpp>
	40
	41	using boost::make_filter_iterator;
	42	using std::dynamic_pointer_cast;
	43	using std::max;
	44	using std::make_pair;
	45	using std::min;
	46	using std::pair;
	47	using std::shared_ptr;
	48	using std::stable_sort;
	49	using std::vector;
	50
	51	namespace pv {
	52	namespace view {
	53
	54	const int Header::Padding = 12;
	55	const int Header::BaselineOffset = 5;
	56
	57	static bool item_selected(shared_ptr<RowItem> r)
	58	{
	59	return r->selected();
	60	}
	61
	62	Header::Header(View &parent) :
	63	MarginWidget(parent)
	64	{
	65	connect(&view_, SIGNAL(signals_moved()),
	66	this, SLOT(on_signals_moved()));
	67	}
	68
	69	QSize Header::sizeHint() const
	70	{
	71	QRectF max_rect(-Padding, 0, Padding, 0);
	72	for (auto &i : view_)
	73	if (i->enabled())
	74	max_rect = max_rect.united(i->label_rect(QRect()));
	75	return QSize(max_rect.width() + Padding + BaselineOffset, 0);
	76	}
	77
	78	QSize Header::extended_size_hint() const
	79	{
	80	return sizeHint() + QSize(ViewItem::HighlightRadius, 0);
	81	}
	82
	83	vector< shared_ptr<ViewItem> > Header::items()
	84	{
	85	return vector< shared_ptr<ViewItem> >(view_.begin(), view_.end());
	86	}
	87
	88	shared_ptr<ViewItem> Header::get_mouse_over_item(const QPoint &pt)
	89	{
	90	const QRect r(0, 0, width() - BaselineOffset, height());
	91	for (auto &i : view_)
	92	if (i->enabled() && i->label_rect(r).contains(pt))
	93	return i;
	94	return shared_ptr<RowItem>();
	95	}
	96
	97	void Header::clear_selection()
	98	{
	99	for (auto &i : view_)
	100	i->select(false);
	101	update();
	102	}
	103
	104	void Header::paintEvent(QPaintEvent*)
	105	{
	106	// The trace labels are not drawn with the arrows exactly on the
	107	// left edge of the widget, because then the selection shadow
	108	// would be clipped away.
	109	const QRect rect(0, 0, width() - BaselineOffset, height());
	110
	111	vector< shared_ptr<RowItem> > row_items(
	112	view_.begin(), view_.end());
	113
	114	stable_sort(row_items.begin(), row_items.end(),
	115	[](const shared_ptr<RowItem> &a, const shared_ptr<RowItem> &b) {
	116	return a->visual_v_offset() < b->visual_v_offset(); });
	117
	118	QPainter painter(this);
	119	painter.setRenderHint(QPainter::Antialiasing);
	120
	121	for (const shared_ptr<RowItem> r : row_items)
	122	{
	123	assert(r);
	124
	125	const bool highlight = !dragging_ &&
	126	r->label_rect(rect).contains(mouse_point_);
	127	r->paint_label(painter, rect, highlight);
	128	}
	129
	130	painter.end();
	131	}
	132
	133	void Header::mouseLeftPressEvent(QMouseEvent *event)
	134	{
	135	(void)event;
	136
	137	const bool ctrl_pressed =
	138	QApplication::keyboardModifiers() & Qt::ControlModifier;
	139
	140	// Clear selection if control is not pressed and this item is unselected
	141	if ((!mouse_down_item_ \|\| !mouse_down_item_->selected()) &&
	142	!ctrl_pressed)
	143	for (shared_ptr<RowItem> r : view_)
	144	r->select(false);
	145
	146	// Set the signal selection state if the item has been clicked
	147	if (mouse_down_item_) {
	148	if (ctrl_pressed)
	149	mouse_down_item_->select(!mouse_down_item_->selected());
	150	else
	151	mouse_down_item_->select(true);
	152	}
	153
	154	// Save the offsets of any signals which will be dragged
	155	for (const shared_ptr<RowItem> r : view_)
	156	if (r->selected())
	157	r->drag();
	158
	159	selection_changed();
	160	update();
	161	}
	162
	163	void Header::mousePressEvent(QMouseEvent *event)
	164	{
	165	assert(event);
	166
	167	mouse_down_point_ = event->pos();
	168	mouse_down_item_ = get_mouse_over_item(event->pos());
	169
	170	if (event->button() & Qt::LeftButton)
	171	mouseLeftPressEvent(event);
	172	}
	173
	174	void Header::mouseLeftReleaseEvent(QMouseEvent *event)
	175	{
	176	assert(event);
	177
	178	const bool ctrl_pressed =
	179	QApplication::keyboardModifiers() & Qt::ControlModifier;
	180
	181	// Unselect everything if control is not pressed
	182	const shared_ptr<ViewItem> mouse_over =
	183	get_mouse_over_item(event->pos());
	184
	185	for (auto &r : view_)
	186	r->drag_release();
	187
	188	if (dragging_)
	189	view_.restack_all_row_items();
	190	else
	191	{
	192	if (!ctrl_pressed) {
	193	for (shared_ptr<RowItem> r : view_)
	194	if (mouse_down_item_ != r)
	195	r->select(false);
	196
	197	if (mouse_down_item_)
	198	show_popup(mouse_down_item_);
	199	}
	200	}
	201
	202	dragging_ = false;
	203	}
	204
	205	void Header::mouseReleaseEvent(QMouseEvent *event)
	206	{
	207	assert(event);
	208	if (event->button() & Qt::LeftButton)
	209	mouseLeftReleaseEvent(event);
	210
	211	mouse_down_item_ = nullptr;
	212	}
	213
	214	void Header::mouseMoveEvent(QMouseEvent *event)
	215	{
	216	assert(event);
	217	mouse_point_ = event->pos();
	218
	219	if (!(event->buttons() & Qt::LeftButton))
	220	return;
	221
	222	if ((event->pos() - mouse_down_point_).manhattanLength() <
	223	QApplication::startDragDistance())
	224	return;
	225
	226	// Check all the drag items share a common owner
	227	RowItemOwner *item_owner = nullptr;
	228	for (shared_ptr<RowItem> r : view_)
	229	if (r->dragging()) {
	230	if (!item_owner)
	231	item_owner = r->owner();
	232	else if(item_owner != r->owner())
	233	return;
	234	}
	235
	236	if (!item_owner)
	237	return;
	238
	239	// Do the drag
	240	dragging_ = true;
	241
	242	const QPoint delta = event->pos() - mouse_down_point_;
	243
	244	for (std::shared_ptr<RowItem> r : view_)
	245	if (r->dragging()) {
	246	r->drag_by(delta);
	247
	248	// Ensure the trace is selected
	249	r->select();
	250	}
	251
	252	item_owner->restack_items();
	253	for (const auto &r : *item_owner)
	254	r->animate_to_layout_v_offset();
	255	signals_moved();
	256
	257	update();
	258	}
	259
	260	void Header::contextMenuEvent(QContextMenuEvent *event)
	261	{
	262	const shared_ptr<ViewItem> r = get_mouse_over_item(mouse_point_);
	263	if (!r)
	264	return;
	265
	266	QMenu *menu = r->create_context_menu(this);
	267	if (!menu)
	268	menu = new QMenu(this);
	269
	270	if (std::count_if(view_.begin(), view_.end(), item_selected) > 1)
	271	{
	272	menu->addSeparator();
	273
	274	QAction *const group = new QAction(tr("Group"), this);
	275	QList<QKeySequence> shortcuts;
	276	shortcuts.append(QKeySequence(Qt::ControlModifier \| Qt::Key_G));
	277	group->setShortcuts(shortcuts);
	278	connect(group, SIGNAL(triggered()), this, SLOT(on_group()));
	279	menu->addAction(group);
	280	}
	281
	282	menu->exec(event->globalPos());
	283	}
	284
	285	void Header::keyPressEvent(QKeyEvent *e)
	286	{
	287	assert(e);
	288
	289	if (e->key() == Qt::Key_Delete)
	290	{
	291	for (const shared_ptr<RowItem> r : view_)
	292	if (r->selected())
	293	r->delete_pressed();
	294	}
	295	else if (e->key() == Qt::Key_G && e->modifiers() == Qt::ControlModifier)
	296	on_group();
	297	else if (e->key() == Qt::Key_U && e->modifiers() == Qt::ControlModifier)
	298	on_ungroup();
	299	}
	300
	301	void Header::on_signals_moved()
	302	{
	303	update();
	304	}
	305
	306	void Header::on_group()
	307	{
	308	vector< shared_ptr<RowItem> > selected_items(
	309	make_filter_iterator(item_selected, view_.begin(), view_.end()),
	310	make_filter_iterator(item_selected, view_.end(), view_.end()));
	311	stable_sort(selected_items.begin(), selected_items.end(),
	312	[](const shared_ptr<RowItem> &a, const shared_ptr<RowItem> &b) {
	313	return a->visual_v_offset() < b->visual_v_offset(); });
	314
	315	shared_ptr<TraceGroup> group(new TraceGroup());
	316	shared_ptr<RowItem> mouse_down_item(
	317	std::dynamic_pointer_cast<RowItem>(mouse_down_item_));
	318	shared_ptr<RowItem> focus_item(
	319	mouse_down_item ? mouse_down_item : selected_items.front());
	320
	321	assert(focus_item);
	322	assert(focus_item->owner());
	323	focus_item->owner()->add_child_item(group);
	324
	325	// Set the group v_offset here before reparenting
	326	group->force_to_v_offset(focus_item->layout_v_offset() +
	327	focus_item->v_extents().first);
	328
	329	for (size_t i = 0; i < selected_items.size(); i++) {
	330	const shared_ptr<RowItem> &r = selected_items[i];
	331	assert(r->owner());
	332	r->owner()->remove_child_item(r);
	333	group->add_child_item(r);
	334
	335	// Put the items at 1-pixel offsets, so that restack will
	336	// stack them in the right order
	337	r->set_layout_v_offset(i);
	338	}
	339	}
	340
	341	void Header::on_ungroup()
	342	{
	343	bool restart;
	344	do {
	345	restart = false;
	346	for (const shared_ptr<RowItem> r : view_) {
	347	const shared_ptr<TraceGroup> tg =
	348	dynamic_pointer_cast<TraceGroup>(r);
	349	if (tg && tg->selected()) {
	350	tg->ungroup();
	351	restart = true;
	352	break;
	353	}
	354	}
	355	} while(restart);
	356	}
	357
	358	} // namespace view
	359	} // namespace pv