This file is indexed.

/usr/include/ganv-1/ganv/wrap.hpp is in libganv-dev 1.4.2~dfsg0-2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  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
/* 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_WRAP_HPP
#define GANV_WRAP_HPP

#include <glib.h>

#define CONNECT_PROP_SIGNAL(gobj, name, notify, handler) \
	g_signal_connect(gobj, "notify::" #name, \
	                 G_CALLBACK(notify), &_signal_##name); \
	_signal_##name.connect(sigc::mem_fun(this, handler));

#define SIGNAL1(name, argtype) \
public: \
	virtual bool on_##name(argtype arg) { return true; } \
	sigc::signal<bool, argtype>& signal_##name() { return _signal_##name; } \
private: \
	sigc::signal<bool, argtype> _signal_##name;

#define RW_PROPERTY(type, name) \
	virtual type get_##name() const { \
		type value; \
		g_object_get(G_OBJECT(_gobj), #name, &value, NULL); \
		return value; \
	} \
	virtual void set_##name(type value) { \
		g_object_set(G_OBJECT(_gobj), #name, value, NULL); \
	} \
	SIGNAL1(name, type) \
	public:

#define RW_OBJECT_PROPERTY(type, name) \
	type get_##name() const { \
		if (!_gobj) return NULL; \
		Ganv##type ptr; \
		g_object_get(G_OBJECT(_gobj), #name, &ptr, NULL); \
		return Glib::wrap(ptr); \
	} \
	void set_##name(type value) { \
		if (!_gobj) return; \
		ganv_item_set(GANV_ITEM(_gobj), \
		              #name, value->gobj(), \
		              NULL); \
	}

#define METHOD0(prefix, name) \
	virtual void name() { \
		prefix##_##name(gobj()); \
	}

#define METHOD1(prefix, name, t1, a1) \
	virtual void name(t1 a1) { \
		prefix##_##name(gobj(), a1); \
	}

#define METHODRET0(prefix, ret, name) \
	virtual ret name() const { \
		return prefix##_##name(gobj()); \
	}

#define METHODRET1(prefix, ret, name, t1, a1) \
	virtual ret name(t1 a1) { \
		return prefix##_##name(gobj(), a1); \
	}

#define METHODRETWRAP0(prefix, ret, name) \
	virtual ret name() const { \
		if (gobj()) { \
			return Glib::wrap(prefix##_##name(gobj())); \
		} else { \
			return NULL; \
		} \
	}

#define METHOD2(prefix, name, t1, a1, t2, a2) \
	virtual void name(t1 a1, t2 a2) { \
		prefix##_##name(gobj(), a1, a2); \
	}

#define METHOD3(prefix, name, t1, a1, t2, a2, t3, a3) \
	virtual void name(t1 a1, t2 a2, t3 a3) { \
		prefix##_##name(gobj(), a1, a2, a3); \
	}

#define METHOD4(prefix, name, t1, a1, t2, a2, t3, a3, t4, a4) \
	virtual void name(t1 a1, t2 a2, t3 a3, t4 a4) { \
		prefix##_##name(gobj(), a1, a2, a3, a4); \
	}

#define GANV_GLIB_WRAP(Name) \
	namespace Ganv { \
	class Name; \
	} \
	namespace Glib { \
	/** Return a Ganv::CPPType wrapper for a CType. */ \
	static inline Ganv::Name* \
	wrap(Ganv##Name* gobj) \
	{ \
		if (gobj) { \
			GQuark key = g_quark_from_string("ganvmm"); \
			return (Ganv::Name*)g_object_get_qdata(G_OBJECT(gobj), key); \
		} else { \
			return NULL; \
		} \
	} \
	}

#endif  // GANV_WRAP_HPP