This file is indexed.

/usr/include/cegui-0.8.7/CEGUI/falagard/WidgetLookManager.h is in libcegui-mk2-dev 0.8.7-1.3+b2.

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
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
/***********************************************************************
    created:    Mon Jun 13 2005
    author:     Paul D Turner <paul@cegui.org.uk>
*************************************************************************/
/***************************************************************************
 *   Copyright (C) 2004 - 2010 Paul D Turner & The CEGUI Development Team
 *
 *   Permission is hereby granted, free of charge, to any person obtaining
 *   a copy of this software and associated documentation files (the
 *   "Software"), to deal in the Software without restriction, including
 *   without limitation the rights to use, copy, modify, merge, publish,
 *   distribute, sublicense, and/or sell copies of the Software, and to
 *   permit persons to whom the Software is furnished to do so, subject to
 *   the following conditions:
 *
 *   The above copyright notice and this permission notice shall be
 *   included in all copies or substantial portions of the Software.
 *
 *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 *   IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 *   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 *   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 *   OTHER DEALINGS IN THE SOFTWARE.
 ***************************************************************************/
#ifndef _CEGUIFalWidgetLookManager_h_
#define _CEGUIFalWidgetLookManager_h_

#include "../Singleton.h"
#include "../String.h"
#include "../Exceptions.h"
#include "./WidgetLookFeel.h"
#include <map>

#if defined(_MSC_VER)
#	pragma warning(push)
#	pragma warning(disable : 4251)
#	pragma warning(disable : 4275)
#endif

// Start of CEGUI namespace section
namespace CEGUI
{
    /*!
    \brief
        Manager class that gives top-level access to widget data based "look and feel" specifications loaded into the system.
    */
    class CEGUIEXPORT WidgetLookManager :
        public Singleton<WidgetLookManager>,
        public AllocatedObject<WidgetLookManager>
    {
    public:
        /*!
        \brief
            Constructor.
        */
        WidgetLookManager();

        /*!
        \brief
            Destructor
        */
        ~WidgetLookManager();

       	/*!
	      \brief
		        Return singleton WidgetLookManager object

	      \return
		        Singleton WidgetLookManager object
	      */
	      static	WidgetLookManager&	getSingleton(void);


	      /*!
	      \brief
		        Return pointer to singleton WidgetLookManager object

	      \return
		        Pointer to singleton WidgetLookManager object
	      */
	      static	WidgetLookManager*	getSingletonPtr(void);


        /** Typedef for a set of WidgetLookFeel names. */
        typedef std::set<String, StringFastLessCompare CEGUI_SET_ALLOC(String)> WidgetLookNameSet;

        //! Typedef for a map of Strings to WidgetLookFeel objects
        typedef std::map<String, WidgetLookFeel*, StringFastLessCompare CEGUI_MAP_ALLOC(String, WidgetLookFeel*)> WidgetLookPointerMap;

        /*!
        \brief
            Parses a file containing window look & feel specifications (in the form of XML).

        \note
            If the new file contains specifications for widget types that are already specified, it is not an error;
            the previous definitions are overwritten by the new data.  An entry will appear in the log each time any
            look & feel component is overwritten.

        \param source
            RawDataContainer containing the source code that will be parsed

        \param resourceGroup
            Resource group identifier to pass to the resource provider when loading the file.

        \return
            Nothing.

        \exception FileIOException             thrown if there was some problem accessing or parsing the file \a filename
        \exception InvalidRequestException     thrown if an invalid filename was provided.
        */
        void parseLookNFeelSpecificationFromContainer(const RawDataContainer& source);
        
        /*!
        \see WidgetLookManager::parseLookNFeelSpecificationFromContainer
        */
        void parseLookNFeelSpecificationFromFile(const String& filename, const String& resourceGroup = "");
        
        /*!
        \see WidgetLookManager::parseLookNFeelSpecificationFromContainer
        */
        void parseLookNFeelSpecificationFromString(const String& source);

        /*!
        \brief
            Return whether a WidgetLookFeel has been created with the specified name.

        \param widget
            String object holding the name of a widget look to test for.

        \return
            - true if a WidgetLookFeel named \a widget is available.
            - false if so such WidgetLookFeel is currently available.
        */
        bool isWidgetLookAvailable(const String& widget) const;


        /*!
        \brief
            Return a const reference to a WidgetLookFeel object which has the specified name.

        \param widget
            String object holding the name of a widget look that is to be returned.

        \return
            const reference to the requested WidgetLookFeel object.

        \exception UnknownObjectException   thrown if no WidgetLookFeel is available with the requested name.
        */
        const WidgetLookFeel& getWidgetLook(const String& widget) const;


        /*!
        \brief
            Erase the WidgetLookFeel that has the specified name.

        \param widget
            String object holding the name of a widget look to be erased.  If no such WidgetLookFeel exists, nothing
            happens.

        \return
            Nothing.
        */
        void eraseWidgetLook(const String& widget);

        //! erase all defined WidgetLookFeel.
        void eraseAllWidgetLooks();

        /*!
        \brief
            Add the given WidgetLookFeel.

        \note
            If the WidgetLookFeel specification uses a name that already exists within the system, it is not an error;
            the previous definition is overwritten by the new data.  An entry will appear in the log each time any
            look & feel component is overwritten.

        \param look
            WidgetLookFeel object to be added to the system.  NB: The WidgetLookFeel is copied, no change of ownership of the
            input object occurrs.

        \return
            Nothing.
        */
        void addWidgetLook(const WidgetLookFeel& look);


        /*!
        \brief
            Writes a complete WidgetLookFeel to a stream. Note that XML file header and
            Falagard opening/closing tags will also be written.

        \param name
            String holding the name of the WidgetLookFeel to be output to the stream.

        \param out_stream
            OutStream where XML data should be sent.
        */
        void writeWidgetLookToStream(const String& widgetLookName, OutStream& out_stream) const;

        /*!
        \brief
            Writes a complete WidgetLookFeel to a string. Note that XML file header and
            Falagard opening/closing tags will also be written.

        \param name
            String holding the name of the WidgetLookFeel to be output to the string.

        \return
            String containing the WidgetLook parsed to XML.
        */
        String getWidgetLookAsString(const String& widgetLookName) const;
 
        /*!
        \brief
            Writes a set WidgetLookFeels to a string. Note that XML file header and
            Falagard opening/closing tags will also be written.

        \param widgetLookNameSet
            Set of strings containing the WidgetLookFeel names to be output to the string.

        \return
            String containing the set of WidgetLookFeels parsed to XML.
        */
        String getWidgetLookSetAsString(const WidgetLookNameSet& widgetLookNameSet) const;

        /*!
        \brief
            Writes a series of complete WidgetLook objects to a stream. Note that XML file header and
            Falagard opening/closing tags will also be written.

            The \a prefix specifies a name prefix common to all widget looks to be written, you could
            specify this as "TaharezLook/" and then any defined widget look starting with that prefix, such
            as "TaharezLook/Button" and "TaharezLook/Listbox" will be written to the stream.

        \param prefix
            String holding the widget look name prefix, which will be used when searching for the widget looks
            to be output to the stream.

        \param out_stream
            OutStream where XML data should be sent.
        */
        void writeWidgetLookSeriesToStream(const String& prefix, OutStream& out_stream) const;

        /*!
        \brief
            Writes a series of complete WidgetLook objects to a stream. Note that XML file header and
            Falagard opening/closing tags will also be written.

            The \a widgetLookSet specifies a set of strings containing the names of the WidgetLookFeels
            to be written to the stream.

        \param widgetLookNameSet
            Set of strings containing the WidgetLookFeel names to be added to be written to the stream.

        \param out_stream
            OutStream where XML data should be sent.
        */
        void writeWidgetLookSetToStream(const WidgetLookNameSet& widgetLookNameSet, OutStream& out_stream) const;

        /*!
        \brief
            Returns the default resource group currently set for LookNFeels.

        \return
            String describing the default resource group identifier that will be
            used when loading LookNFeel data.
        */
        static const String& getDefaultResourceGroup()
            { return d_defaultResourceGroup; }

        /*!
        \brief
            Sets the default resource group to be used when loading LookNFeel data

        \param resourceGroup
            String describing the default resource group identifier to be used.

        \return
            Nothing.
        */
        static void setDefaultResourceGroup(const String& resourceGroup)
            { d_defaultResourceGroup = resourceGroup; }

        /*!
        \brief
            Returns a map containing Strings to WidgetLookFeel pointers. The map contains pointers to the WidgetLookFeels
            that were added to this Manager.

        \return
            A map of Strings to WidgetLookFeel pointers.
        */
        WidgetLookPointerMap getWidgetLookPointerMap();

    private:
        //! Name of schema file used for XML validation.
        static const String FalagardSchemaName; 
        //! holds default resource group
        static String d_defaultResourceGroup;


        //! Typedef for a map of Strings to WidgetLookFeel objects
        // \deprecated  Will use the correct allocator in the next version and will
        // be renamed to "WidgetLookMap"
        typedef std::map<String, WidgetLookFeel, StringFastLessCompare> WidgetLookList;

        //! List of WidgetLookFeels added to this Manager
        WidgetLookList  d_widgetLooks;  

    public:
        //! \deprecated Use WidgetLookPointerMap instead, which provides direct access to the added elements.
        typedef ConstMapIterator<WidgetLookList> WidgetLookIterator;
        //! \deprecated Use getWidgetLookPointerMap instead, which provides direct access to the added elements. In the next version getWidgetLookMap will be added to replace the const-ness.
        WidgetLookIterator getWidgetLookIterator() const;
    };

} // End of  CEGUI namespace section


#if defined(_MSC_VER)
#	pragma warning(pop)
#endif

#endif  // end of guard _CEGUIFalWidgetLookManager_h_