File: Module.hpp

package info (click to toggle)
ganv 0~svn4468~dfsg0-1
  • links: PTS, VCS
  • area: main
  • in suites: wheezy
  • size: 1,232 kB
  • sloc: python: 12,014; ansic: 6,656; cpp: 2,437; sh: 40; makefile: 23
file content (130 lines) | stat: -rw-r--r-- 3,818 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
/* This file is part of Ganv.
 * Copyright 2007-2012 David Robillard <http://drobilla.net>
 *
 * Ganv 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 3 of the License, or any later version.
 *
 * Ganv 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 details.
 *
 * You should have received a copy of the GNU General Public License along
 * with Ganv.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef GANV_MODULE_HPP
#define GANV_MODULE_HPP

#include <string>
#include <vector>

#include <gtkmm/container.h>

#include "ganv/Canvas.hpp"
#include "ganv/Node.hpp"
#include "ganv/Port.hpp"
#include "ganv/module.h"

GANV_GLIB_WRAP(Module)

namespace Ganv {

class Canvas;

/** A rectangular Item which can hold a Port.
 *
 * @ingroup Ganv
 */
class Module : public Box
{
public:
	Module(Canvas&            canvas,
	       const std::string& name,
	       double             x                = 0,
	       double             y                = 0,
	       bool               show_title       = true)
		: Box(&canvas, GANV_BOX(
			      ganv_item_new(
				      GANV_ITEM(canvas.root()),
				      ganv_module_get_type(),
				      "x", x,
				      "y", y,
				      "can-tail", FALSE,
				      "can-head", FALSE,
				      "radius-tl", 4.0,
				      "radius-tr", 4.0,
				      "radius-br", 4.0,
				      "radius-bl", 4.0,
				      "label", name.c_str(),
				      "draggable", TRUE,
				      NULL)))
	{}

	template<typename P, typename C>
	class iterator_base {
	public:
		iterator_base(GanvModule* m, guint i) : _module(m), _index(i) {}
		template<typename T, typename U>
		iterator_base(const iterator_base<T, U>& i)
			: _module(i._module)
			, _index(i._index)
		{}
		P* operator*() const {
			return Glib::wrap(ganv_module_get_port(_module, _index));
		}
		P* operator->() const {
			return Glib::wrap(ganv_module_get_port(_module, _index));
		}
		iterator_base operator++(int) const {
			return iterator_base<P, C>(_index + 1);
		}
		iterator_base& operator++() {
			++_index; return *this;
		}
		bool operator==(const iterator_base<P, C>& i) const {
			return _index == i._index;
		}
		bool operator!=(const iterator_base<P, C>& i) const {
			return _index != i._index;
		}
	private:
		template<typename T, typename U> friend class iterator_base;
		GanvModule* _module;
		guint       _index;
	};

	typedef iterator_base<Port, GanvPort>             iterator;
	typedef iterator_base<const Port, const GanvPort> const_iterator;

	iterator       begin()       { return iterator(gobj(), 0); }
	iterator       end()         { return iterator(gobj(), num_ports()); }
	iterator       back()        { return iterator(gobj(), num_ports() - 1); }
	const_iterator begin() const { return iterator(const_cast<GanvModule*>(gobj()), 0); }
	const_iterator end()   const { return iterator(const_cast<GanvModule*>(gobj()), num_ports()); }
	const_iterator back()  const { return iterator(const_cast<GanvModule*>(gobj()), num_ports() - 1); }

	void embed(Gtk::Widget* widget) {
		if (widget) {
			ganv_module_embed(gobj(), widget->gobj());
		} else {
			ganv_module_embed(gobj(), NULL);
		}
	}

	METHOD2(ganv_module, for_each_port, GanvPortFunc, f, void*, data);

	METHODRET0(ganv_module, guint, num_ports);

	RW_PROPERTY(gboolean, stacked)

	METHODRET0(ganv_module, double, get_empty_port_breadth)
	METHODRET0(ganv_module, double, get_empty_port_depth)

	GanvModule*       gobj()       { return GANV_MODULE(_gobj); }
	const GanvModule* gobj() const { return GANV_MODULE(_gobj); }
};

} // namespace Ganv

#endif // GANV_MODULE_HPP