This file is indexed.

/usr/share/idl/bonobo-2.0/Bonobo_Property.idl is in libbonobo2-common 2.32.1-3.

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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
/*
 * bonobo-property.idl: The Bonobo Property interfaces.
 *
 * Authors:
 *   Nat Friedman   (nat@nat.org)
 *   Michael Meeks  (michael@ximian.com)
 *   Dietmar Maurer (dietmar@ximian.com)
 *   Mike Kestner   (mkestner@ameritech.net)
 *
 * Copyright 1999, 2000, 2001 Ximian, Inc.
 * Copyright 2000, Mike Kestner
 */

 /*
  * Each PropertyBag is aggregated with an EventSource, so that it is
  * possible to attach event listeners. The event name is composed
  * of "Bonobo/Property", the type of the event and finally the property
  * name - everything separated by colons. At the moment there is only one 
  * type defined - "change". So if a property with name "autosave" changes
  * its value, we emit an event with the name: 
  * "Bonobo/Property:change:autosave"
  */

#ifndef BONOBO_PROPERTY_IDL
#define BONOBO_PROPERTY_IDL

#include "Bonobo_Unknown.idl"
#include "Bonobo_Listener.idl"

module Bonobo {

struct Pair {
	string name;
	any    value;
};

typedef sequence<Pair> PropertySet;

typedef sequence<string> KeyList;

typedef long PropertyFlags;
const PropertyFlags PROPERTY_READABLE        = 1;
const PropertyFlags PROPERTY_WRITEABLE       = 2;
const PropertyFlags PROPERTY_NO_LISTENING    = 4;
const PropertyFlags PROPERTY_NO_AUTONOTIFY   = 8;
const PropertyFlags PROPERTY_NO_PERSIST      = 16;

interface PropertyBag : Bonobo::Unknown {

	exception NotFound {};
	exception InvalidType {};
	exception _ReadOnly {};
	exception BackendFailed {};

	/**
	 * getKeys:
	 *
	 * Returns: A list of keys matching @filter.
	 */
	KeyList         getKeys    (in string filter)
		raises (NotFound, BackendFailed);
 
	/**
	 * getType:
	 * 
	 * Returns: The type of property @key.
	 */
#ifdef __ORBIT_IDL__
	TypeCode        getType     (in string key)
#else
	CORBA::TypeCode getType     (in string key)
#endif
		raises (NotFound, BackendFailed);


	/**
	 * getValue:
	 *
	 * Returns: The current value for property @key.
	 */
	any             getValue    (in string key)
		raises (NotFound, BackendFailed);

	/**
	 * setValue:
	 * 
	 * Sets the value for property @key to @value
	 */
	void            setValue    (in string key, in any value)
		raises (NotFound, InvalidType, ReadOnly, BackendFailed);
  

	/**
	 * getValue:
	 *
	 * Returns: A list of properties matching @filter.
	 */
	PropertySet     getValues   (in string filter)
 		raises (NotFound, BackendFailed);
	
	/**
	 * setValue:
	 * 
	 * Sets the values contained in @set. 
	 */
	void            setValues   (in PropertySet set)
		raises (InvalidType, ReadOnly, BackendFailed);
	
	/**
	 * getDefault:
	 *
	 * Returns: The default value for property @key.
	 *
	 * Property editors can use it to implement a "set property value to
	 * default" mechanism.
	 *
	 */
	any             getDefault  (in string key)
		raises (NotFound, BackendFailed);
                
	/**
	 * getDocTitle:
	 *
	 * Returns: A short string describing property @key.
	 */	
	string          getDocTitle (in string key)
		raises (NotFound, BackendFailed);
                
	/**
	 * getDoc:
	 *
	 * Returns: A verbose documentation describing property @key.
	 */	
	string          getDoc      (in string key)
		raises (NotFound, BackendFailed);

	/** 
	 * getFlags:
	 * 
	 * Returns:
	 */
	PropertyFlags   getFlags    (in string key)
		raises (NotFound, BackendFailed);

	void unImplemented1 ();
	void unImplemented2 ();
	void unImplemented3 ();
	void unImplemented4 ();
};

interface ConfigDatabase : PropertyBag {

	enum DBFlags {
		_DEFAULT,
		WRITE,
		MANDATORY
	};

	/** 
	 * isWriteable:
	 * 
	 * indicates whether the database is writeable or not
	 */
	readonly attribute boolean isWriteable;
	
	/** 
	 * getDirs:
	 * 
	 * Returns: A list of directory names.
	 */
	KeyList         getDirs     (in string dir)
		raises (NotFound, BackendFailed);

	/** 
	 * hasDir:
	 * 
	 * Returns: TRUE if @dir exists. 
	 */
	boolean         hasDir      (in string dir)
		raises (BackendFailed);
		
	/** 
	 * removeValue:
	 * 
	 * Remove a value from the database.
	 */
	void            removeValue (in string key)
		raises (BackendFailed);

	/** 
	 * removeDir:
	 * 
	 * Removes all values contained in directory.
	 */
	void            removeDir   (in string dir)
		raises (BackendFailed);

	/** 
	 * addDatabase:
	 * 
	 * The added database will be used to lookup default values.
	 */
	void            addDatabase (in ConfigDatabase db, in string key, 
				     in DBFlags flags)
		raises (BackendFailed);

	/** 
	 * sync:
	 * 
	 * Flush all buffers 
	 */
	void            sync        ()
		raises (BackendFailed);

	void unImplemented5 ();
	void unImplemented6 ();
	void unImplemented7 ();
	void unImplemented8 ();
};

};

#endif /* BONOBO_PROPERTY_IDL */