1
=== modified file '.bzrignore'
2
--- .bzrignore	2014-04-11 13:58:10 +0000
3
+++ .bzrignore	2014-08-21 18:21:03 +0000
4
@@ -2,3 +2,5 @@
5
2
.cproject
2
.cproject
6
3
.settings
3
.settings
7
4
build
4
build
8
5
*~
9
6
*.user
10
5
7
11
=== modified file 'CMakeLists.txt'
12
--- CMakeLists.txt	2014-05-28 15:29:04 +0000
13
+++ CMakeLists.txt	2014-08-21 18:21:03 +0000
14
@@ -1,31 +1,22 @@
15
1
# Copyright © 2013 Canonical Ltd.
16
2
#
17
3
# This program is free software: you can redistribute it and/or modify it
18
4
# under the terms of the GNU Lesser General Public License version 3,
19
5
# as published by the Free Software Foundation.
20
6
#
21
7
# This program is distributed in the hope that it will be useful,
22
8
# but WITHOUT ANY WARRANTY; without even the implied warranty of
23
9
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
24
10
# GNU Lesser General Public License for more details.
25
11
#
26
12
# You should have received a copy of the GNU Lesser General Public License
27
13
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
28
14
#
29
15
# Authors:
30
16
#     Antti Kaijanmäki <antti.kaijanmaki@canonical.com>
31
17
32
18
cmake_minimum_required(VERSION 2.8)
1
cmake_minimum_required(VERSION 2.8)
33
19
project(connectivity-cpp)
2
project(connectivity-cpp)
34
20
3
35
4
string(TOLOWER "${CMAKE_BUILD_TYPE}" build_type_lower)
36
5
37
21
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)
6
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)
38
22
7
39
23
include(EnableCoverageReport)
8
include(EnableCoverageReport)
40
24
include(GNUInstallDirs)
9
include(GNUInstallDirs)
41
25
10
45
26
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -pedantic -Wextra -fPIC -fvisibility=hidden -pthread")
11
set(COMMON_FLAGS "-Wall -Wextra -Wpedantic -fno-permissive -fPIC -fvisibility=hidden -pthread")
46
27
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Wall -fno-strict-aliasing -fvisibility=hidden -fvisibility-inlines-hidden -pedantic -Wextra -fPIC -pthread")
12
if(NOT build_type_lower MATCHES debug)
47
28
#set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--no-undefined")
13
    set(COMMON_FLAGS "${COMMON_FLAGS} -Werror")
48
14
endif()
49
15
50
16
# "nice bug" in cmake... http://www.cmake.org/Bug/view.php?id=15058
51
17
# let's not set C_FLAGS as it will break pthreads detection \o/
52
18
#set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${COMMON_FLAGS}")
53
19
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 ${COMMON_FLAGS} -fno-strict-aliasing -fvisibility-inlines-hidden")
54
29
20
55
30
#####################################################################
21
#####################################################################
56
31
# Enable code coverage calculation with gcov/gcovr/lcov
22
# Enable code coverage calculation with gcov/gcovr/lcov
57
@@ -35,78 +26,25 @@
58
35
#  * Find html report in subdir coveragereport
26
#  * Find html report in subdir coveragereport
59
36
#  * Find xml report feasible for jenkins in coverage.xml
27
#  * Find xml report feasible for jenkins in coverage.xml
60
37
#####################################################################
28
#####################################################################
62
38
IF(CMAKE_BUILD_TYPE MATCHES [cC][oO][vV][eE][rR][aA][gG][eE])
29
IF(build_type_lower MATCHES coverage)
63
39
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftest-coverage -fprofile-arcs" )
30
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftest-coverage -fprofile-arcs" )
64
40
  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ftest-coverage -fprofile-arcs" )
31
  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ftest-coverage -fprofile-arcs" )
65
41
  SET(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -ftest-coverage -fprofile-arcs" )
32
  SET(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -ftest-coverage -fprofile-arcs" )
66
42
  SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -ftest-coverage -fprofile-arcs" )
33
  SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -ftest-coverage -fprofile-arcs" )
72
43
ENDIF(CMAKE_BUILD_TYPE MATCHES [cC][oO][vV][eE][rR][aA][gG][eE])
34
ENDIF()
68
44
69
45
set(CONNECTIVITY_CPP_VERSION_MAJOR 0)
70
46
set(CONNECTIVITY_CPP_VERSION_MINOR 0)
71
47
set(CONNECTIVITY_CPP_VERSION_PATCH 1)
73
48
35
74
49
include(CTest)
36
include(CTest)
75
50
37
76
51
find_package(PkgConfig REQUIRED)
38
find_package(PkgConfig REQUIRED)
77
52
39
125
53
include_directories(include)
40
set(CONNECTIVITY_QT_VERSION_MAJOR 1)
126
54
include_directories(dbus-cpp)
41
set(CONNECTIVITY_QT_VERSION_MINOR 0)
127
55
42
set(CONNECTIVITY_QT_LIB_TARGET connectivity-qt${CONNECTIVITY_QT_VERSION_MAJOR})
128
56
pkg_check_modules(
43
82
57
    PROPERTIESCPP REQUIRED
83
58
    properties-cpp
84
59
)
85
60
include_directories(${PROPERTIESCPP_INCLUDE_DIRS})
86
61
87
62
pkg_check_modules(
88
63
    DBUSCPP REQUIRED
89
64
    dbus-cpp
90
65
)
91
66
include_directories(${DBUSCPP_INCLUDE_DIRS})
92
67
93
68
pkg_check_modules(
94
69
    NETWORKMANAGER REQUIRED
95
70
    NetworkManager
96
71
)
97
72
include_directories(${NETWORKMANAGER_NCLUDE_DIRS})
98
73
99
74
# list these here to have them visible in Qt Creator
100
75
set(CONNECTIVITY_INTERFACES
101
76
    include/connectivity/networking/link.h
102
77
    include/connectivity/networking/manager.h
103
78
    include/connectivity/networking/service.h
104
79
105
80
    include/connectivity/networking/service/tethering/service.h
106
81
    include/connectivity/networking/service/tor/service.h
107
82
    include/connectivity/networking/service/vpn/service.h
108
83
109
84
    include/connectivity/networking/wifi/access-point.h
110
85
    include/connectivity/networking/wifi/link.h
111
86
112
87
    include/connectivity/networking/wwan/link.h
113
88
)
114
89
add_custom_target(QtCreatorHeaderHack SOURCES ${CONNECTIVITY_INTERFACES})
115
90
116
91
# list these here to have them visible in Qt Creator
117
92
set(DBUS_INTERFACES
118
93
    dbus-cpp/services/nm.h
119
94
    dbus-cpp/services/ofono.h
120
95
    dbus-cpp/services/urfkill.h
121
96
)
122
97
add_custom_target(QtCreatorHeaderHack2 SOURCES ${DBUS_INTERFACES})
123
98
124
99
add_subdirectory(data)
129
100
add_subdirectory(doc)
44
add_subdirectory(doc)
130
101
add_subdirectory(examples)
131
102
enable_testing()
45
enable_testing()
132
103
add_subdirectory(tests)
46
add_subdirectory(tests)
133
104
add_subdirectory(src)
47
add_subdirectory(src)
134
105
48
141
106
install(
49
enable_coverage_report(TARGETS connectivity-qt1
136
107
    DIRECTORY include/
137
108
    DESTINATION include/connectivity-cpp-${CONNECTIVITY_CPP_VERSION_MAJOR}
138
109
)
139
110
140
111
enable_coverage_report(TARGETS connectivity-cpp
142
112
                       FILTER ${CMAKE_SOURCE_DIR}/tests/* ${CMAKE_BINARY_DIR}/*)
50
                       FILTER ${CMAKE_SOURCE_DIR}/tests/* ${CMAKE_BINARY_DIR}/*)
143
113
51
144
=== removed directory 'data'
145
=== removed file 'data/CMakeLists.txt'
146
--- data/CMakeLists.txt	2014-01-23 22:09:36 +0000
147
+++ data/CMakeLists.txt	1970-01-01 00:00:00 +0000
148
@@ -1,26 +0,0 @@
149
1
# Copyright © 2013 Canonical Ltd.
150
2
#
151
3
# This program is free software: you can redistribute it and/or modify it
152
4
# under the terms of the GNU Lesser General Public License version 3,
153
5
# as published by the Free Software Foundation.
154
6
#
155
7
# This program is distributed in the hope that it will be useful,
156
8
# but WITHOUT ANY WARRANTY; without even the implied warranty of
157
9
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
158
10
# GNU Lesser General Public License for more details.
159
11
#
160
12
# You should have received a copy of the GNU Lesser General Public License
161
13
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
162
14
#
163
15
# Authors:
164
16
#     Antti Kaijanmäki <antti.kaijanmaki@canonical.com>
165
17
166
18
configure_file(
167
19
	connectivity-cpp.pc.in connectivity-cpp.pc @ONLY
168
20
)
169
21
170
22
install(
171
23
	FILES ${CMAKE_CURRENT_BINARY_DIR}/connectivity-cpp.pc
172
24
	DESTINATION lib/pkgconfig
173
25
)
174
26
175
27
0
176
=== removed file 'data/connectivity-cpp.pc.in'
177
--- data/connectivity-cpp.pc.in	2014-04-23 14:18:33 +0000
178
+++ data/connectivity-cpp.pc.in	1970-01-01 00:00:00 +0000
179
@@ -1,11 +0,0 @@
180
1
prefix=@CMAKE_INSTALL_PREFIX@
181
2
exec_prefix=${prefix}
182
3
libdir=${exec_prefix}/@CMAKE_INSTALL_LIBDIR@
183
4
includedir=${exec_prefix}/include
184
5
 
185
6
Name: @CMAKE_PROJECT_NAME@
186
7
Description: 
187
8
Version: @CONNECTIVITY_CPP_VERSION_MAJOR@.@CONNECTIVITY_CPP_VERSION_MINOR@.@CONNECTIVITY_CPP_VERSION_PATCH@
188
9
Cflags: -I${includedir}/connectivity-cpp-@CONNECTIVITY_CPP_VERSION_MAJOR@
189
10
Libs: -L${libdir} -lconnectivity-cpp
190
11
Requires: dbus-cpp properties-cpp
191
12
0
192
=== removed file 'data/session.conf'
193
--- data/session.conf	2014-01-23 22:09:36 +0000
194
+++ data/session.conf	1970-01-01 00:00:00 +0000
195
@@ -1,42 +0,0 @@
196
1
<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-Bus Bus Configuration 1.0//EN"
197
2
 "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
198
3
<busconfig>
199
4
  <!-- If we fork, keep the user's original umask to avoid affecting
200
5
       the behavior of child processes. -->
201
6
  <keep_umask/>
202
7
203
8
  <type>session</type>
204
9
205
10
  <listen>unix:tmpdir=/tmp</listen>
206
11
207
12
  <standard_session_servicedirs />
208
13
209
14
  <policy context="default">
210
15
    <!-- Allow everything to be sent -->
211
16
    <allow send_destination="*" eavesdrop="true"/>
212
17
    <!-- Allow everything to be received -->
213
18
    <allow eavesdrop="true"/>
214
19
    <!-- Allow anyone to own anything -->
215
20
    <allow own="*"/>
216
21
  </policy>
217
22
218
23
  <!-- raise the service start timeout to 40 seconds as it can timeout
219
24
       on the live cd on slow machines -->
220
25
  <limit name="service_start_timeout">60000</limit>
221
26
222
27
  <!-- the memory limits are 1G instead of say 4G because they can't exceed 32-bit signed int max -->
223
28
  <limit name="max_incoming_bytes">1000000000</limit>
224
29
  <limit name="max_outgoing_bytes">1000000000</limit>
225
30
  <limit name="max_message_size">1000000000</limit>
226
31
  <limit name="service_start_timeout">120000</limit>  
227
32
  <limit name="auth_timeout">240000</limit>
228
33
  <limit name="max_completed_connections">100000</limit>  
229
34
  <limit name="max_incomplete_connections">10000</limit>
230
35
  <limit name="max_connections_per_user">100000</limit>
231
36
  <limit name="max_pending_service_starts">10000</limit>
232
37
  <limit name="max_names_per_connection">50000</limit>
233
38
  <limit name="max_match_rules_per_connection">50000</limit>
234
39
  <limit name="max_replies_per_connection">50000</limit>
235
40
  <limit name="reply_timeout">300000</limit>
236
41
237
42
</busconfig>
238
43
0
239
=== removed file 'data/system.conf'
240
--- data/system.conf	2014-01-23 22:09:36 +0000
241
+++ data/system.conf	1970-01-01 00:00:00 +0000
242
@@ -1,23 +0,0 @@
243
1
<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-Bus Bus Configuration 1.0//EN"
244
2
 "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
245
3
<busconfig>
246
4
  <!-- If we fork, keep the user's original umask to avoid affecting
247
5
       the behavior of child processes. -->
248
6
  <keep_umask/>
249
7
250
8
  <type>system</type>
251
9
252
10
  <listen>unix:tmpdir=/tmp</listen>
253
11
254
12
  <standard_system_servicedirs/>
255
13
256
14
  <policy context="default">
257
15
    <!-- Allow everything to be sent -->
258
16
    <allow send_destination="*" eavesdrop="true"/>
259
17
    <!-- Allow everything to be received -->
260
18
    <allow eavesdrop="true"/>
261
19
    <!-- Allow anyone to own anything -->
262
20
    <allow own="*"/>
263
21
  </policy>
264
22
265
23
</busconfig>
266
24
0
267
=== removed directory 'dbus-cpp'
268
=== removed directory 'dbus-cpp/services'
269
=== removed file 'dbus-cpp/services/nm.h'
270
--- dbus-cpp/services/nm.h	2014-04-30 12:06:30 +0000
271
+++ dbus-cpp/services/nm.h	1970-01-01 00:00:00 +0000
272
@@ -1,986 +0,0 @@
273
1
/*
274
2
 * Copyright © 2012-2013 Canonical Ltd.
275
3
 *
276
4
 * This program is free software: you can redistribute it and/or modify it
277
5
 * under the terms of the GNU Lesser General Public License version 3,
278
6
 * as published by the Free Software Foundation.
279
7
 *
280
8
 * This program is distributed in the hope that it will be useful,
281
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
282
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
283
11
 * GNU Lesser General Public License for more details.
284
12
 *
285
13
 * You should have received a copy of the GNU Lesser General Public License
286
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
287
15
 *
288
16
 * Authored by: Antti Kaijanmäki <antti.kaijanmaki@canonical.com>
289
17
 */
290
18
#ifndef PLATFORM_MANAGER_NMOFONO_NM_H
291
19
#define PLATFORM_MANAGER_NMOFONO_NM_H
292
20
293
21
#include <core/dbus/bus.h>
294
22
#include <core/dbus/object.h>
295
23
#include <core/dbus/property.h>
296
24
#include <core/dbus/service.h>
297
25
#include <core/dbus/types/object_path.h>
298
26
#include <core/dbus/types/any.h>
299
27
#include <core/dbus/types/struct.h>
300
28
#include <core/dbus/types/stl/map.h>
301
29
#include <core/dbus/types/stl/string.h>
302
30
#include <core/dbus/types/stl/tuple.h>
303
31
#include <core/dbus/types/stl/vector.h>
304
32
#include <NetworkManager/NetworkManager.h>
305
33
#include "util.h"
306
34
307
35
namespace org
308
36
{
309
37
namespace freedesktop
310
38
{
311
39
namespace NetworkManager
312
40
{
313
41
    struct Interface {
314
42
315
43
        struct AccessPoint
316
44
        {
317
45
            static const std::string& name()
318
46
            {
319
47
                static const std::string s{NM_DBUS_INTERFACE_ACCESS_POINT};
320
48
                return s;
321
49
            }
322
50
323
51
            struct Property {
324
52
                struct Frequency
325
53
                {
326
54
                    static const std::string& name()
327
55
                    {
328
56
                        static const std::string s{"Frequency"};
329
57
                        return s;
330
58
                    }
331
59
332
60
                    typedef AccessPoint Interface;
333
61
                    typedef std::uint32_t ValueType;
334
62
                    static const bool readable = true;
335
63
                    static const bool writable = false;
336
64
                };
337
65
338
66
                struct Flags
339
67
                {
340
68
                    static const std::string& name()
341
69
                    {
342
70
                        static const std::string s{"Flags"};
343
71
                        return s;
344
72
                    }
345
73
346
74
                    typedef AccessPoint Interface;
347
75
                    typedef std::uint32_t ValueType;
348
76
                    static const bool readable = true;
349
77
                    static const bool writable = false;
350
78
                };
351
79
352
80
                struct WpaFlags
353
81
                {
354
82
                    static const std::string& name()
355
83
                    {
356
84
                        static const std::string s{"WpaFlags"};
357
85
                        return s;
358
86
                    }
359
87
360
88
                    typedef AccessPoint Interface;
361
89
                    typedef std::uint32_t ValueType;
362
90
                    static const bool readable = true;
363
91
                    static const bool writable = false;
364
92
                };
365
93
366
94
                struct RsnFlags
367
95
                {
368
96
                    static const std::string& name()
369
97
                    {
370
98
                        static const std::string s{"RsnFlags"};
371
99
                        return s;
372
100
                    }
373
101
374
102
                    typedef AccessPoint Interface;
375
103
                    typedef std::uint32_t ValueType;
376
104
                    static const bool readable = true;
377
105
                    static const bool writable = false;
378
106
                };
379
107
380
108
                struct Mode
381
109
                {
382
110
                    static const std::string& name()
383
111
                    {
384
112
                        static const std::string s{"Mode"};
385
113
                        return s;
386
114
                    }
387
115
388
116
                    typedef AccessPoint Interface;
389
117
                    typedef std::uint32_t ValueType;
390
118
                    static const bool readable = true;
391
119
                    static const bool writable = false;
392
120
                };
393
121
394
122
                struct Ssid
395
123
                {
396
124
                    static const std::string& name()
397
125
                    {
398
126
                        static const std::string s{"Ssid"};
399
127
                        return s;
400
128
                    }
401
129
402
130
                    typedef AccessPoint Interface;
403
131
                    /// @todo bug tvoss.. D-Bus BYTE(y) should be unsigned
404
132
                    typedef std::vector<std::int8_t> ValueType;
405
133
                    static const bool readable = true;
406
134
                    static const bool writable = false;
407
135
                };
408
136
409
137
                struct HwAddress
410
138
                {
411
139
                    static const std::string& name()
412
140
                    {
413
141
                        static const std::string s{"HwAddress"};
414
142
                        return s;
415
143
                    }
416
144
417
145
                    typedef AccessPoint Interface;
418
146
                    typedef std::string ValueType;
419
147
                    static const bool readable = true;
420
148
                    static const bool writable = false;
421
149
                };
422
150
423
151
                struct Strength
424
152
                {
425
153
                    static const std::string& name()
426
154
                    {
427
155
                        static const std::string s{"Strength"};
428
156
                        return s;
429
157
                    }
430
158
431
159
                    typedef AccessPoint Interface;
432
160
                    typedef std::int8_t ValueType;
433
161
                    static const bool readable = true;
434
162
                    static const bool writable = false;
435
163
                };
436
164
            };
437
165
438
166
            struct Signal {
439
167
                struct PropertiesChanged
440
168
                {
441
169
                    static const std::string& name()
442
170
                    {
443
171
                        static const std::string s{"PropertiesChanged"};
444
172
                        return s;
445
173
                    }
446
174
447
175
                    typedef AccessPoint Interface;
448
176
                    typedef std::map<std::string, core::dbus::types::Variant> ArgumentType;
449
177
                };
450
178
            };
451
179
452
180
            AccessPoint(const std::shared_ptr<core::dbus::Object>& object)
453
181
                : object(object),
454
182
                  frequency(object->get_property<Property::Frequency>()),
455
183
                  hw_address(object->get_property<Property::HwAddress>()),
456
184
                  strength(object->get_property<Property::Strength>()),
457
185
                  flags(object->get_property<Property::Flags>()),
458
186
                  wpa_flags(object->get_property<Property::WpaFlags>()),
459
187
                  rsn_flags(object->get_property<Property::RsnFlags>()),
460
188
                  mode(object->get_property<Property::Mode>()),
461
189
                  ssid(object->get_property<Property::Ssid>()),
462
190
                  properties_changed(object->get_signal<Signal::PropertiesChanged>())
463
191
464
192
            {}
465
193
466
194
            std::shared_ptr<core::dbus::Object> object;
467
195
            std::shared_ptr<core::dbus::Property<Property::Frequency>> frequency;
468
196
            std::shared_ptr<core::dbus::Property<Property::HwAddress>> hw_address;
469
197
            std::shared_ptr<core::dbus::Property<Property::Strength>> strength;
470
198
            std::shared_ptr<core::dbus::Property<Property::Flags>> flags;
471
199
            std::shared_ptr<core::dbus::Property<Property::WpaFlags>> wpa_flags;
472
200
            std::shared_ptr<core::dbus::Property<Property::RsnFlags>> rsn_flags;
473
201
            std::shared_ptr<core::dbus::Property<Property::Mode>> mode;
474
202
            std::shared_ptr<core::dbus::Property<Property::Ssid>> ssid;
475
203
            std::shared_ptr<core::dbus::Signal<Signal::PropertiesChanged, Signal::PropertiesChanged::ArgumentType>> properties_changed;
476
204
        }; // Interface::AccessPoint
477
205
478
206
479
207
        struct ActiveConnection
480
208
        {
481
209
            static const std::string& name()
482
210
            {
483
211
                static const std::string s{NM_DBUS_INTERFACE_ACTIVE_CONNECTION};
484
212
                return s;
485
213
            }
486
214
487
215
            struct Property {
488
216
                struct Connection
489
217
                {
490
218
                    static const std::string& name()
491
219
                    {
492
220
                        static const std::string s{"Connection"};
493
221
                        return s;
494
222
                    }
495
223
496
224
                    typedef ActiveConnection Interface;
497
225
                    typedef core::dbus::types::ObjectPath ValueType;
498
226
                    static const bool readable = true;
499
227
                    static const bool writable = false;
500
228
                };
501
229
                struct SpecificObject
502
230
                {
503
231
                    static const std::string& name()
504
232
                    {
505
233
                        static const std::string s{"SpecificObject"};
506
234
                        return s;
507
235
                    }
508
236
509
237
                    typedef ActiveConnection Interface;
510
238
                    typedef core::dbus::types::ObjectPath ValueType;
511
239
                    static const bool readable = true;
512
240
                    static const bool writable = false;
513
241
                };
514
242
                struct Uuid
515
243
                {
516
244
                    static const std::string& name()
517
245
                    {
518
246
                        static const std::string s{"Uuid"};
519
247
                        return s;
520
248
                    }
521
249
522
250
                    typedef ActiveConnection Interface;
523
251
                    typedef std::string ValueType;
524
252
                    static const bool readable = true;
525
253
                    static const bool writable = false;
526
254
                };
527
255
                struct Devices
528
256
                {
529
257
                    static const std::string& name()
530
258
                    {
531
259
                        static const std::string s{"Devices"};
532
260
                        return s;
533
261
                    }
534
262
535
263
                    typedef ActiveConnection Interface;
536
264
                    typedef std::vector<core::dbus::types::ObjectPath> ValueType;
537
265
                    static const bool readable = true;
538
266
                    static const bool writable = false;
539
267
                };
540
268
                struct State
541
269
                {
542
270
                    static const std::string& name()
543
271
                    {
544
272
                        static const std::string s{"State"};
545
273
                        return s;
546
274
                    }
547
275
548
276
                    typedef ActiveConnection Interface;
549
277
                    typedef std::uint32_t ValueType;
550
278
                    static const bool readable = true;
551
279
                    static const bool writable = false;
552
280
                };
553
281
                struct Default
554
282
                {
555
283
                    static const std::string& name()
556
284
                    {
557
285
                        static const std::string s{"Default"};
558
286
                        return s;
559
287
                    }
560
288
561
289
                    typedef ActiveConnection Interface;
562
290
                    typedef bool ValueType;
563
291
                    static const bool readable = true;
564
292
                    static const bool writable = false;
565
293
                };
566
294
                struct Default6
567
295
                {
568
296
                    static const std::string& name()
569
297
                    {
570
298
                        static const std::string s{"Default6"};
571
299
                        return s;
572
300
                    }
573
301
574
302
                    typedef ActiveConnection Interface;
575
303
                    typedef bool ValueType;
576
304
                    static const bool readable = true;
577
305
                    static const bool writable = false;
578
306
                };
579
307
                struct Vpn
580
308
                {
581
309
                    static const std::string& name()
582
310
                    {
583
311
                        static const std::string s{"Vpn"};
584
312
                        return s;
585
313
                    }
586
314
587
315
                    typedef ActiveConnection Interface;
588
316
                    typedef bool ValueType;
589
317
                    static const bool readable = true;
590
318
                    static const bool writable = false;
591
319
                };
592
320
                struct Master
593
321
                {
594
322
                    static const std::string& name()
595
323
                    {
596
324
                        static const std::string s{"Master"};
597
325
                        return s;
598
326
                    }
599
327
600
328
                    typedef ActiveConnection Interface;
601
329
                    typedef bool ValueType;
602
330
                    static const bool readable = true;
603
331
                    static const bool writable = false;
604
332
                };
605
333
            }; // struct Property
606
334
607
335
            struct Signal {
608
336
                struct PropertiesChanged
609
337
                {
610
338
                    static const std::string& name()
611
339
                    {
612
340
                        static const std::string s{"PropertiesChanged"};
613
341
                        return s;
614
342
                    }
615
343
616
344
                    typedef ActiveConnection Interface;
617
345
                    typedef std::map<std::string, core::dbus::types::Variant> ArgumentType;
618
346
                };
619
347
            };
620
348
621
349
            enum class State
622
350
            {
623
351
                unknown      = NM_ACTIVE_CONNECTION_STATE_UNKNOWN,
624
352
                activating   = NM_ACTIVE_CONNECTION_STATE_ACTIVATING,
625
353
                activated    = NM_ACTIVE_CONNECTION_STATE_ACTIVATED,
626
354
                deactivating = NM_ACTIVE_CONNECTION_STATE_DEACTIVATING,
627
355
                deactivated  = NM_ACTIVE_CONNECTION_STATE_DEACTIVATED
628
356
            };
629
357
630
358
            ActiveConnection(const std::shared_ptr<core::dbus::Object>& object)
631
359
                : object(object),
632
360
                  connection(object->get_property<Property::Connection>()),
633
361
                  specific_object(object->get_property<Property::SpecificObject>()),
634
362
                  uuid(object->get_property<Property::Uuid>()),
635
363
                  devices(object->get_property<Property::Devices>()),
636
364
                  state(object->get_property<Property::State>()),
637
365
                  default_ipv4(object->get_property<Property::Default>()),
638
366
                  default_ipv6(object->get_property<Property::Default6>()),
639
367
                  vpn(object->get_property<Property::Vpn>()),
640
368
                  master(object->get_property<Property::Master>()),
641
369
                  properties_changed(object->get_signal<Signal::PropertiesChanged>())
642
370
            {
643
371
                token = properties_changed->connect([this](const Signal::PropertiesChanged::ArgumentType &map){
644
372
                    for (auto entry: map) {
645
373
                        if (entry.first == "State") {
646
374
#if 0
647
375
                            std::uint32_t new_value = entry.second.as<std::uint32_t>();
648
376
                            state->update([&new_value](std::uint32_t &current_value){
649
377
                                if (new_value == current_value)
650
378
                                    return false;
651
379
                                current_value = new_value;
652
380
                                return true;
653
381
                            });
654
382
#endif
655
383
                            continue;
656
384
                        }
657
385
                        else {
658
386
                            std::cout << "Unexpected Connection.Active update: " << entry.first << std::endl;
659
387
                        }
660
388
                    }
661
389
                });
662
390
            }
663
391
            ~ActiveConnection()
664
392
            {
665
393
                /// @todo fix dbus-cpp...
666
394
                //properties_changed->disconnect(token);
667
395
            }
668
396
669
397
            State get_state() { return static_cast<State>(state->get()); }
670
398
671
399
            std::shared_ptr<core::dbus::Object> object;
672
400
            std::shared_ptr<core::dbus::Property<Property::Connection>> connection;
673
401
            std::shared_ptr<core::dbus::Property<Property::SpecificObject>> specific_object;
674
402
            std::shared_ptr<core::dbus::Property<Property::Uuid>> uuid;
675
403
            std::shared_ptr<core::dbus::Property<Property::Devices>> devices;
676
404
            std::shared_ptr<core::dbus::Property<Property::State>> state;
677
405
            std::shared_ptr<core::dbus::Property<Property::Default>> default_ipv4;
678
406
            std::shared_ptr<core::dbus::Property<Property::Default6>> default_ipv6;
679
407
            std::shared_ptr<core::dbus::Property<Property::Vpn>> vpn;
680
408
            std::shared_ptr<core::dbus::Property<Property::Master>> master;
681
409
682
410
        private:
683
411
            std::shared_ptr<core::dbus::Signal<Signal::PropertiesChanged, Signal::PropertiesChanged::ArgumentType>> properties_changed;
684
412
            core::dbus::Signal<Signal::PropertiesChanged, Signal::PropertiesChanged::ArgumentType>::SubscriptionToken token;
685
413
        };  // Interface::ActiveConnection
686
414
687
415
        struct Connection
688
416
        {
689
417
            std::shared_ptr<core::dbus::Object> object;
690
418
691
419
            Connection(const std::shared_ptr<core::dbus::Object>& object)
692
420
                : object(object)
693
421
            {}
694
422
695
423
            static const std::string& name()
696
424
            {
697
425
                static const std::string s{NM_DBUS_IFACE_SETTINGS_CONNECTION};
698
426
                return s;
699
427
            }
700
428
701
429
            struct Method {
702
430
                struct GetSettings
703
431
                {
704
432
                    static const std::string& name()
705
433
                    {
706
434
                        static const std::string s{"GetSettings"};
707
435
                        return s;
708
436
                    }
709
437
710
438
                    typedef Connection Interface;
711
439
                    typedef std::map<std::string, std::map<std::string, core::dbus::types::Variant>> ResultType;
712
440
713
441
                    static std::chrono::milliseconds default_timeout()
714
442
                    {
715
443
                        return std::chrono::seconds{1};
716
444
                    }
717
445
                };
718
446
            };
719
447
720
448
            Method::GetSettings::ResultType
721
449
            get_settings()
722
450
            {
723
451
724
452
                auto result = object->invoke_method_synchronously<Method::GetSettings, Method::GetSettings::ResultType>();
725
453
726
454
                if (result.is_error())
727
455
                    connectivity::throw_dbus_exception(result.error());
728
456
729
457
                return result.value();
730
458
            }
731
459
        }; // Interface::Connection
732
460
733
461
        struct Device
734
462
        {
735
463
            static const std::string& name()
736
464
            {
737
465
                static const std::string s{NM_DBUS_INTERFACE_DEVICE};
738
466
                return s;
739
467
            }
740
468
741
469
            enum class Type
742
470
            {
743
471
                unknown     = NM_DEVICE_TYPE_UNKNOWN,
744
472
                ethernet    = NM_DEVICE_TYPE_ETHERNET,
745
473
                wifi        = NM_DEVICE_TYPE_WIFI,
746
474
                unused_1    = NM_DEVICE_TYPE_UNUSED1,
747
475
                unused_2    = NM_DEVICE_TYPE_UNUSED2,
748
476
                bluetooth   = NM_DEVICE_TYPE_BT,
749
477
                olpc_mesh   = NM_DEVICE_TYPE_OLPC_MESH,
750
478
                wimax       = NM_DEVICE_TYPE_WIMAX,
751
479
                modem       = NM_DEVICE_TYPE_MODEM,
752
480
                infiniband  = NM_DEVICE_TYPE_INFINIBAND,
753
481
                bond        = NM_DEVICE_TYPE_BOND,
754
482
                vlan        = NM_DEVICE_TYPE_VLAN,
755
483
                adsl        = NM_DEVICE_TYPE_ADSL,
756
484
                bridge      = NM_DEVICE_TYPE_BRIDGE
757
485
            };
758
486
759
487
            struct Wireless
760
488
            {
761
489
                static const std::string& name()
762
490
                {
763
491
                    static const std::string s{NM_DBUS_INTERFACE_DEVICE_WIRELESS};
764
492
                    return s;
765
493
                }
766
494
767
495
                struct Method {
768
496
                    struct GetAccessPoints
769
497
                    {
770
498
                        static const std::string& name()
771
499
                        {
772
500
                            static const std::string s{"GetAccessPoints"};
773
501
                            return s;
774
502
                        }
775
503
776
504
                        typedef Wireless Interface;
777
505
                        typedef std::vector<core::dbus::types::ObjectPath> ResultType;
778
506
779
507
                        static std::chrono::milliseconds default_timeout()
780
508
                        {
781
509
                            return std::chrono::seconds{1};
782
510
                        }
783
511
                    };
784
512
                };
785
513
786
514
                struct Signal {
787
515
                    struct AccessPointAdded
788
516
                    {
789
517
                        static const std::string& name()
790
518
                        {
791
519
                            static const std::string s{"AccessPointAdded"};
792
520
                            return s;
793
521
                        }
794
522
795
523
                        typedef Wireless Interface;
796
524
                        typedef core::dbus::types::ObjectPath ArgumentType;
797
525
                    };
798
526
799
527
                    struct AccessPointRemoved
800
528
                    {
801
529
                        static const std::string& name()
802
530
                        {
803
531
                            static const std::string s{"AccessPointRemoved"};
804
532
                            return s;
805
533
                        }
806
534
807
535
                        typedef Wireless Interface;
808
536
                        typedef core::dbus::types::ObjectPath ArgumentType;
809
537
                    };
810
538
                };
811
539
812
540
                Wireless(std::shared_ptr<core::dbus::Object> &base)
813
541
                    : access_point_added(base->get_signal<Signal::AccessPointAdded>()),
814
542
                      access_point_removed(base->get_signal<Signal::AccessPointRemoved>())
815
543
                {}
816
544
817
545
                std::shared_ptr<core::dbus::Signal<Signal::AccessPointAdded, Signal::AccessPointAdded::ArgumentType>> access_point_added;
818
546
                std::shared_ptr<core::dbus::Signal<Signal::AccessPointRemoved, Signal::AccessPointRemoved::ArgumentType>> access_point_removed;
819
547
820
548
            }; // Interface::Device::Wireless
821
549
822
550
            struct Property {
823
551
                struct DeviceType
824
552
                {
825
553
                    static const std::string& name()
826
554
                    {
827
555
                        static const std::string s{"DeviceType"};
828
556
                        return s;
829
557
                    }
830
558
831
559
                    typedef Device Interface;
832
560
                    typedef std::uint32_t ValueType;
833
561
                    static const bool readable = true;
834
562
                    static const bool writable = false;
835
563
                };
836
564
837
565
                struct DeviceInterface {
838
566
                    static const std::string& name()
839
567
                    {
840
568
                        static const std::string s{"Interface"};
841
569
                        return s;
842
570
                    }
843
571
844
572
                    typedef Device Interface;
845
573
                    typedef std::string ValueType;
846
574
                    static const bool readable = true;
847
575
                    static const bool writable = false;
848
576
                };
849
577
850
578
                struct Autoconnect
851
579
                {
852
580
                    static const std::string& name()
853
581
                    {
854
582
                        static const std::string s{"Autoconnect"};
855
583
                        return s;
856
584
                    }
857
585
858
586
                    typedef Device Interface;
859
587
                    typedef bool ValueType;
860
588
                    static const bool readable = true;
861
589
                    static const bool writable = true;
862
590
                };
863
591
864
592
                struct State {
865
593
                    static const std::string &name()
866
594
                    {
867
595
                        static const std::string s{"State"};
868
596
                        return s;
869
597
                    }
870
598
871
599
                    typedef Device Interface;
872
600
                    typedef std::uint32_t ValueType;
873
601
                    static const bool readable = true;
874
602
                    static const bool writable = false;
875
603
                };
876
604
877
605
                struct AvailableConnections {
878
606
                    static const std::string &name()
879
607
                    {
880
608
                        static const std::string s{"AvailableConnections"};
881
609
                        return s;
882
610
                    }
883
611
884
612
                    typedef Device Interface;
885
613
                    typedef std::vector<core::dbus::types::ObjectPath> ValueType;
886
614
                    static const bool readable = true;
887
615
                    static const bool writable = false;
888
616
                };
889
617
890
618
                struct ActiveConnection {
891
619
                    static const std::string &name()
892
620
                    {
893
621
                        static const std::string s{"ActiveConnection"};
894
622
                        return s;
895
623
                    }
896
624
897
625
                    typedef Device Interface;
898
626
                    typedef core::dbus::types::ObjectPath ValueType;
899
627
                    static const bool readable = true;
900
628
                    static const bool writable = false;
901
629
                };
902
630
            };
903
631
904
632
            std::vector<Connection>
905
633
            get_available_connections() {
906
634
                std::vector<Connection> list;
907
635
                for (auto c: available_connections->get()) {
908
636
                    list.push_back(Connection(service->object_for_path(c)));
909
637
                }
910
638
                return list;
911
639
            }
912
640
913
641
            struct Method {
914
642
915
643
                struct Disconnect
916
644
                {
917
645
                    static const std::string& name()
918
646
                    {
919
647
                        static const std::string s{"Disconnect"};
920
648
                        return s;
921
649
                    }
922
650
923
651
                    typedef Device Interface;
924
652
                    typedef void ResultType;
925
653
926
654
                    static std::chrono::milliseconds default_timeout()
927
655
                    {
928
656
                        return std::chrono::seconds{1};
929
657
                    }
930
658
                };
931
659
            };
932
660
933
661
            void disconnect()
934
662
            {
935
663
                auto result =
936
664
                        object->invoke_method_synchronously<
937
665
                            Device::Method::Disconnect, Device::Method::Disconnect::ResultType>();
938
666
939
667
                if (result.is_error())
940
668
                    connectivity::throw_dbus_exception(result.error());
941
669
            }
942
670
943
671
            struct Signal {
944
672
                struct StateChanged
945
673
                {
946
674
                    static const std::string& name()
947
675
                    {
948
676
                        static const std::string s{"StateChanged"};
949
677
                        return s;
950
678
                    }
951
679
952
680
                    typedef Device Interface;
953
681
                    typedef std::tuple<std::uint32_t, std::uint32_t, std::uint32_t> ArgumentType;
954
682
                };
955
683
            };
956
684
957
685
958
686
            Type type() const
959
687
            {
960
688
                return static_cast<Type>(device_type->get());
961
689
            }
962
690
963
691
            std::string interface() const
964
692
            {
965
693
                return device_interface->get();
966
694
            }
967
695
968
696
            Wireless::Method::GetAccessPoints::ResultType get_access_points() const
969
697
            {
970
698
                auto result = object->invoke_method_synchronously<Wireless::Method::GetAccessPoints,
971
699
                                                                  Wireless::Method::GetAccessPoints::ResultType>();
972
700
973
701
                if (result.is_error())
974
702
                    connectivity::throw_dbus_exception(result.error());
975
703
976
704
                return result.value();
977
705
            }
978
706
979
707
            Device(const std::shared_ptr<core::dbus::Service>& service,
980
708
                   const std::shared_ptr<core::dbus::Object>& object)
981
709
                : service(service),
982
710
                  object(object),
983
711
                  device_type(object->get_property<Property::DeviceType>()),
984
712
                  autoconnect(object->get_property<Property::Autoconnect>()),
985
713
                  device_interface(object->get_property<Property::DeviceInterface>()),
986
714
                  state(object->get_property<Property::State>()),
987
715
                  state_changed(object->get_signal<Signal::StateChanged>()),
988
716
                  available_connections(object->get_property<Property::AvailableConnections>()),
989
717
                  active_connection(object->get_property<Property::ActiveConnection>())
990
718
            {}
991
719
992
720
            std::shared_ptr<core::dbus::Service> service;
993
721
            std::shared_ptr<core::dbus::Object> object;
994
722
            std::shared_ptr<core::dbus::Property<Property::DeviceType>> device_type;
995
723
            std::shared_ptr<core::dbus::Property<Property::Autoconnect>> autoconnect;
996
724
            std::shared_ptr<core::dbus::Property<Property::DeviceInterface>> device_interface;
997
725
            std::shared_ptr<core::dbus::Property<Property::State>> state;
998
726
            std::shared_ptr<core::dbus::Signal<Signal::StateChanged, Signal::StateChanged::ArgumentType>> state_changed;
999
727
            std::shared_ptr<core::dbus::Property<Property::AvailableConnections>> available_connections;
1000
728
            std::shared_ptr<core::dbus::Property<Property::ActiveConnection>> active_connection;
1001
729
        }; // Interface::Device
1002
730
1003
731
        struct NetworkManager
1004
732
        {
1005
733
            static const std::string& name()
1006
734
            {
1007
735
                static const std::string s{NM_DBUS_INTERFACE};
1008
736
                return s;
1009
737
            }
1010
738
1011
739
            struct Method {
1012
740
                struct ActivateConnection
1013
741
                {
1014
742
                    static const std::string& name()
1015
743
                    {
1016
744
                        static const std::string s{"ActivateConnection"};
1017
745
                        return s;
1018
746
                    }
1019
747
1020
748
                    typedef NetworkManager Interface;
1021
749
                    typedef core::dbus::types::ObjectPath ResultType;
1022
750
1023
751
                    static std::chrono::milliseconds default_timeout()
1024
752
                    {
1025
753
                        return std::chrono::seconds{1};
1026
754
                    }
1027
755
                };
1028
756
1029
757
                struct AddAndActivateConnection
1030
758
                {
1031
759
                    static const std::string& name()
1032
760
                    {
1033
761
                        static const std::string s{"AddAndActivateConnection"};
1034
762
                        return s;
1035
763
                    }
1036
764
1037
765
                    typedef NetworkManager Interface;
1038
766
                    typedef std::tuple<core::dbus::types::ObjectPath, core::dbus::types::ObjectPath> ResultType;
1039
767
1040
768
                    static std::chrono::milliseconds default_timeout()
1041
769
                    {
1042
770
                        return std::chrono::seconds{1};
1043
771
                    }
1044
772
                };
1045
773
1046
774
                struct GetDevices
1047
775
                {
1048
776
                    static const std::string& name()
1049
777
                    {
1050
778
                        static const std::string s{"GetDevices"};
1051
779
                        return s;
1052
780
                    }
1053
781
1054
782
                    typedef NetworkManager Interface;
1055
783
                    typedef std::vector<core::dbus::types::ObjectPath> ResultType;
1056
784
1057
785
                    static std::chrono::milliseconds default_timeout()
1058
786
                    {
1059
787
                        return std::chrono::seconds{1};
1060
788
                    }
1061
789
                };
1062
790
1063
791
            };
1064
792
1065
793
1066
794
            struct Property
1067
795
            {
1068
796
                struct WirelessEnabled {
1069
797
                    static const std::string &name()
1070
798
                    {
1071
799
                        static const std::string s{"WirelessEnabled"};
1072
800
                        return s;
1073
801
                    }
1074
802
1075
803
                    typedef NetworkManager Interface;
1076
804
                    typedef bool ValueType;
1077
805
                    static const bool readable = true;
1078
806
                    static const bool writable = true;
1079
807
                };
1080
808
1081
809
                struct State {
1082
810
                    static const std::string &name()
1083
811
                    {
1084
812
                        static const std::string s{"State"};
1085
813
                        return s;
1086
814
                    }
1087
815
1088
816
                    typedef NetworkManager Interface;
1089
817
                    typedef std::uint32_t ValueType;
1090
818
                    static const bool readable = true;
1091
819
                    static const bool writable = false;
1092
820
                };
1093
821
1094
822
                struct PrimaryConnection {
1095
823
                    static const std::string &name()
1096
824
                    {
1097
825
                        static const std::string s{"PrimaryConnection"};
1098
826
                        return s;
1099
827
                    }
1100
828
1101
829
                    typedef NetworkManager Interface;
1102
830
                    typedef core::dbus::types::ObjectPath ValueType;
1103
831
                    static const bool readable = true;
1104
832
                    static const bool writable = false;
1105
833
                };
1106
834
1107
835
            };
1108
836
1109
837
            struct Signal {
1110
838
1111
839
                struct PropertiesChanged
1112
840
                {
1113
841
                    static const std::string& name()
1114
842
                    {
1115
843
                        static const std::string s{"PropertiesChanged"};
1116
844
                        return s;
1117
845
                    }
1118
846
1119
847
                    typedef NetworkManager Interface;
1120
848
                    typedef std::map<std::string, core::dbus::types::Variant> ArgumentType;
1121
849
                };
1122
850
1123
851
                struct DeviceAdded
1124
852
                {
1125
853
                    static const std::string& name()
1126
854
                    {
1127
855
                        static const std::string s{"DeviceAdded"};
1128
856
                        return s;
1129
857
                    }
1130
858
1131
859
                    typedef NetworkManager Interface;
1132
860
                    typedef core::dbus::types::ObjectPath ArgumentType;
1133
861
                };
1134
862
1135
863
                struct DeviceRemoved
1136
864
                {
1137
865
                    static const std::string& name()
1138
866
                    {
1139
867
                        static const std::string s{"DeviceRemoved"};
1140
868
                        return s;
1141
869
                    }
1142
870
1143
871
                    typedef NetworkManager Interface;
1144
872
                    typedef core::dbus::types::ObjectPath ArgumentType;
1145
873
                };
1146
874
            };
1147
875
1148
876
            Method::ActivateConnection::ResultType
1149
877
            activate_connection(const core::dbus::types::ObjectPath &connection,
1150
878
                                const core::dbus::types::ObjectPath &device,
1151
879
                                const core::dbus::types::ObjectPath &specific_object)
1152
880
            {
1153
881
                auto result =
1154
882
                        object->invoke_method_synchronously<
1155
883
                            Method::ActivateConnection,
1156
884
                            Method::ActivateConnection::ResultType>
1157
885
                        (connection, device, specific_object);
1158
886
1159
887
                if (result.is_error())
1160
888
                    connectivity::throw_dbus_exception(result.error());
1161
889
1162
890
                return result.value();
1163
891
            }
1164
892
1165
893
            Method::AddAndActivateConnection::ResultType
1166
894
            add_and_activate_connection(std::map<std::string, std::map<std::string, core::dbus::types::Variant>> &connection,
1167
895
                                        const core::dbus::types::ObjectPath &device,
1168
896
                                        const core::dbus::types::ObjectPath &specific_object)
1169
897
            {
1170
898
                auto result =
1171
899
                        object->invoke_method_synchronously<
1172
900
                            Method::AddAndActivateConnection,
1173
901
                            Method::AddAndActivateConnection::ResultType>
1174
902
                        (connection, device, specific_object);
1175
903
1176
904
                if (result.is_error())
1177
905
                    connectivity::throw_dbus_exception(result.error());
1178
906
1179
907
1180
908
                /// @todo return the settings (std::get<0>) object at some point
1181
909
                return result.value();
1182
910
            }
1183
911
1184
912
            std::vector<Device> get_devices()
1185
913
            {
1186
914
                auto result =
1187
915
                        object->invoke_method_synchronously<
1188
916
                            Method::GetDevices,
1189
917
                            Method::GetDevices::ResultType>();
1190
918
1191
919
                if (result.is_error())
1192
920
                    connectivity::throw_dbus_exception(result.error());
1193
921
1194
922
                std::vector<Device> devices;
1195
923
                for (const auto& path : result.value())
1196
924
                {
1197
925
                    devices.emplace_back(
1198
926
                                Device(
1199
927
                                    service,
1200
928
                                    service->object_for_path(path)));
1201
929
                }
1202
930
1203
931
                return devices;
1204
932
            }
1205
933
1206
934
            NetworkManager(std::shared_ptr<core::dbus::Service> &service,
1207
935
                           std::shared_ptr<core::dbus::Object> &object)
1208
936
                : service(service),
1209
937
                  object(object),
1210
938
                  wireless_enabled(object->get_property<Property::WirelessEnabled>()),
1211
939
                  state(object->get_property<Property::State>()),
1212
940
                  properties_changed(object->get_signal<Signal::PropertiesChanged>()),
1213
941
                  primary_connection(object->get_property<Property::PrimaryConnection>()),
1214
942
                  device_added(object->get_signal<Signal::DeviceAdded>()),
1215
943
                  device_removed(object->get_signal<Signal::DeviceRemoved>())
1216
944
            {
1217
945
            }
1218
946
1219
947
            std::shared_ptr<core::dbus::Service> service;
1220
948
            std::shared_ptr<core::dbus::Object> object;
1221
949
1222
950
            std::shared_ptr<core::dbus::Property<Property::WirelessEnabled>> wireless_enabled;
1223
951
            std::shared_ptr<core::dbus::Property<Property::State>> state;
1224
952
            std::shared_ptr<core::dbus::Signal<Signal::PropertiesChanged, Signal::PropertiesChanged::ArgumentType>> properties_changed;
1225
953
            std::shared_ptr<core::dbus::Property<Property::PrimaryConnection>> primary_connection;
1226
954
            std::shared_ptr<core::dbus::Signal<Signal::DeviceAdded, Signal::DeviceAdded::ArgumentType>> device_added;
1227
955
            std::shared_ptr<core::dbus::Signal<Signal::DeviceRemoved, Signal::DeviceRemoved::ArgumentType>> device_removed;
1228
956
        }; // Interface::NetworkManager
1229
957
    };
1230
958
1231
959
    struct Service
1232
960
    {
1233
961
        std::shared_ptr<Interface::NetworkManager> nm;
1234
962
1235
963
        Service(const core::dbus::Bus::Ptr& bus)
1236
964
        {
1237
965
            auto service = core::dbus::Service::use_service<Interface::NetworkManager>(bus);
1238
966
            auto object = service->object_for_path(core::dbus::types::ObjectPath(NM_DBUS_PATH));
1239
967
            nm = std::make_shared<Interface::NetworkManager>(service, object);
1240
968
        }
1241
969
1242
970
        struct Mock
1243
971
        {
1244
972
            std::shared_ptr<Interface::NetworkManager> nm;
1245
973
1246
974
            Mock(const core::dbus::Bus::Ptr& bus)
1247
975
            {
1248
976
                auto service = core::dbus::Service::add_service<Interface::NetworkManager>(bus);
1249
977
                auto object = service->add_object_for_path(core::dbus::types::ObjectPath(NM_DBUS_PATH));
1250
978
                nm = std::make_shared<Interface::NetworkManager>(service, object);
1251
979
            }
1252
980
        };
1253
981
    };
1254
982
}
1255
983
}
1256
984
}
1257
985
1258
986
#endif // PLATFORM_MANAGER_NMOFONO_NM_H
1259
987
0
1260
=== removed file 'dbus-cpp/services/ofono.h'
1261
--- dbus-cpp/services/ofono.h	2014-04-14 07:39:46 +0000
1262
+++ dbus-cpp/services/ofono.h	1970-01-01 00:00:00 +0000
1263
@@ -1,339 +0,0 @@
1264
1
/*
1265
2
 * Copyright © 2012-2013 Canonical Ltd.
1266
3
 *
1267
4
 * This program is free software: you can redistribute it and/or modify it
1268
5
 * under the terms of the GNU Lesser General Public License version 3,
1269
6
 * as published by the Free Software Foundation.
1270
7
 *
1271
8
 * This program is distributed in the hope that it will be useful,
1272
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1273
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1274
11
 * GNU Lesser General Public License for more details.
1275
12
 *
1276
13
 * You should have received a copy of the GNU Lesser General Public License
1277
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1278
15
 *
1279
16
 * Authored by: Thomas Voß <thomas.voss@canonical.com>
1280
17
 */
1281
18
#ifndef LOCATION_SERVICE_LOCATION_CONNECTIVITY_OFONO_H
1282
19
#define LOCATION_SERVICE_LOCATION_CONNECTIVITY_OFONO_H
1283
20
1284
21
#include <core/dbus/bus.h>
1285
22
#include <core/dbus/object.h>
1286
23
#include <core/dbus/property.h>
1287
24
#include <core/dbus/service.h>
1288
25
#include <core/dbus/types/object_path.h>
1289
26
#include <core/dbus/types/struct.h>
1290
27
#include <core/dbus/types/stl/map.h>
1291
28
#include <core/dbus/types/stl/string.h>
1292
29
#include <core/dbus/types/stl/tuple.h>
1293
30
#include <core/dbus/types/stl/vector.h>
1294
31
#include<com/ubuntu/connectivity/util.h>
1295
32
1296
33
namespace org
1297
34
{
1298
35
struct Ofono
1299
36
{
1300
37
static const std::string& name()
1301
38
{
1302
39
    static const std::string s{"org.ofono"};
1303
40
    return s;
1304
41
}
1305
42
struct Manager
1306
43
{
1307
44
    static const std::string& name()
1308
45
    {
1309
46
        static const std::string s{"org.ofono.Manager"};
1310
47
        return s;
1311
48
    }
1312
49
1313
50
    struct GetModems
1314
51
    {
1315
52
        static const std::string& name()
1316
53
        {
1317
54
            static const std::string s{"GetModems"};
1318
55
            return s;
1319
56
        }
1320
57
1321
58
        typedef Manager Interface;
1322
59
        typedef std::vector<
1323
60
            core::dbus::types::Struct<
1324
61
                core::dbus::types::ObjectPath
1325
62
            >
1326
63
        > ResultType;
1327
64
1328
65
        static std::chrono::milliseconds default_timeout()
1329
66
        {
1330
67
            return std::chrono::seconds{1};
1331
68
        }
1332
69
    };
1333
70
1334
71
    struct ModemAdded
1335
72
    {
1336
73
        static const std::string& name()
1337
74
        {
1338
75
            static const std::string s{"ModemAdded"};
1339
76
            return s;
1340
77
        }
1341
78
1342
79
        typedef Manager Interface;
1343
80
        typedef std::tuple<core::dbus::types::ObjectPath, std::map<std::string, std::string>> ArgumentType;
1344
81
    };
1345
82
1346
83
    struct ModemRemoved
1347
84
    {
1348
85
        static const std::string& name()
1349
86
        {
1350
87
            static const std::string s{"ModemRemoved"};
1351
88
            return s;
1352
89
        }
1353
90
1354
91
        typedef Manager Interface;
1355
92
        typedef core::dbus::types::ObjectPath ArgumentType;
1356
93
    };
1357
94
1358
95
    struct Modem
1359
96
    {
1360
97
        struct NetworkRegistration
1361
98
        {
1362
99
            static const std::string& name()
1363
100
            {
1364
101
                static const std::string s{"org.ofono.NetworkRegistration"};
1365
102
                return s;
1366
103
            }
1367
104
1368
105
            struct GetProperties
1369
106
            {
1370
107
                static const std::string& name()
1371
108
                {
1372
109
                    static const std::string s{"GetProperties"};
1373
110
                    return s;
1374
111
                }
1375
112
1376
113
                typedef NetworkRegistration Interface;
1377
114
                typedef std::map<std::string, core::dbus::types::Variant<>> ValueType;
1378
115
1379
116
                static std::chrono::milliseconds default_timeout()
1380
117
                {
1381
118
                    return std::chrono::seconds{1};
1382
119
                }
1383
120
            };
1384
121
1385
122
            struct Mode
1386
123
            {
1387
124
                static const char* unregistered() { return "unregistered"; }
1388
125
                static const char* registered() { return "registered"; }
1389
126
                static const char* searching() { return "searching"; }
1390
127
                static const char* denied() { return "denied"; }
1391
128
                static const char* unknown() { return "unknown"; }
1392
129
                static const char* roaming() { return "roaming"; }
1393
130
1394
131
                static const std::string& name()
1395
132
                {
1396
133
                    static const std::string s{"Mode"};
1397
134
                    return s;
1398
135
                }
1399
136
1400
137
                typedef NetworkRegistration Interface;
1401
138
                typedef std::string ValueType;
1402
139
                static const bool readable = true;
1403
140
                static const bool writable = false;
1404
141
            };
1405
142
1406
143
            struct LocationAreaCode
1407
144
            {
1408
145
                static const std::string& name()
1409
146
                {
1410
147
                    static const std::string s{"LocationAreaCode"};
1411
148
                    return s;
1412
149
                }
1413
150
1414
151
                typedef NetworkRegistration Interface;
1415
152
                typedef std::uint16_t ValueType;
1416
153
                static const bool readable = true;
1417
154
                static const bool writable = false;
1418
155
            };
1419
156
1420
157
            struct CellId
1421
158
            {
1422
159
                static const std::string& name()
1423
160
                {
1424
161
                    static const std::string s{"CellId"};
1425
162
                    return s;
1426
163
                }
1427
164
1428
165
                typedef NetworkRegistration Interface;
1429
166
                typedef std::uint32_t ValueType;
1430
167
                static const bool readable = true;
1431
168
                static const bool writable = false;
1432
169
            };
1433
170
1434
171
            struct MobileCountryCode
1435
172
            {
1436
173
                static const std::string& name()
1437
174
                {
1438
175
                    static const std::string s{"MobileCountryCode"};
1439
176
                    return s;
1440
177
                }
1441
178
1442
179
                typedef NetworkRegistration Interface;
1443
180
                typedef std::string ValueType;
1444
181
                static const bool readable = true;
1445
182
                static const bool writable = false;
1446
183
            };
1447
184
1448
185
            struct MobileNetworkCode
1449
186
            {
1450
187
                static const std::string& name()
1451
188
                {
1452
189
                    static const std::string s{"MobileNetworkCode"};
1453
190
                    return s;
1454
191
                }
1455
192
1456
193
                typedef NetworkRegistration Interface;
1457
194
                typedef std::string ValueType;
1458
195
                static const bool readable = true;
1459
196
                static const bool writable = false;
1460
197
            };
1461
198
1462
199
            struct Technology
1463
200
            {
1464
201
                static const char* gsm() { return "gsm"; }
1465
202
                static const char* edge() { return "edge"; }
1466
203
                static const char* umts() { return "umts"; }
1467
204
                static const char* hspa() { return "hspa"; }
1468
205
                static const char* lte() { return "lte"; }
1469
206
1470
207
                static const std::string& name()
1471
208
                {
1472
209
                    static const std::string s{"Technology"};
1473
210
                    return s;
1474
211
                }
1475
212
1476
213
                typedef NetworkRegistration Interface;
1477
214
                typedef std::string ValueType;
1478
215
                static const bool readable = true;
1479
216
                static const bool writable = false;
1480
217
            };
1481
218
1482
219
            struct Strength
1483
220
            {
1484
221
                static const std::string& name()
1485
222
                {
1486
223
                    static const std::string s{"Strength"};
1487
224
                    return s;
1488
225
                }
1489
226
1490
227
                typedef NetworkRegistration Interface;
1491
228
                typedef std::int8_t ValueType;
1492
229
                static const bool readable = true;
1493
230
                static const bool writable = false;
1494
231
            };
1495
232
1496
233
            NetworkRegistration(const std::shared_ptr<core::dbus::Object>& object)
1497
234
                : object(object),
1498
235
                  properties{}
1499
236
            {
1500
237
                auto result = object->invoke_method_synchronously<GetProperties, GetProperties::ValueType>();
1501
238
                if (result.is_error())
1502
239
                    connectivity::throw_dbus_exception(result.error());
1503
240
1504
241
                properties = result.value();
1505
242
            }
1506
243
1507
244
            template<typename Property>
1508
245
            typename Property::ValueType get(
1509
246
                    const typename Property::ValueType& default_value = typename Property::ValueType{}) const
1510
247
            {
1511
248
                try
1512
249
                {
1513
250
                    core::dbus::types::Any value = properties.at(Property::name()).get();
1514
251
                    typename Property::ValueType result; value.reader() >> result;
1515
252
1516
253
                    return result;
1517
254
                } catch(...)
1518
255
                {
1519
256
                }
1520
257
1521
258
                return default_value;
1522
259
            }
1523
260
1524
261
            std::shared_ptr<core::dbus::Object> object;
1525
262
            GetProperties::ValueType properties;
1526
263
        };
1527
264
1528
265
        Modem(const std::shared_ptr<core::dbus::Service>& service,
1529
266
              const std::shared_ptr<core::dbus::Object>& object)
1530
267
            : service(service),
1531
268
              object(object),
1532
269
              network_registration{object}
1533
270
        {
1534
271
        }
1535
272
1536
273
        std::shared_ptr<core::dbus::Service> service;
1537
274
        std::shared_ptr<core::dbus::Object> object;
1538
275
        NetworkRegistration network_registration;
1539
276
    };
1540
277
1541
278
    Manager(const core::dbus::Bus::Ptr& bus)
1542
279
        : service(core::dbus::Service::use_service<org::Ofono>(bus)),
1543
280
          object(service->object_for_path(core::dbus::types::ObjectPath("/"))),
1544
281
          modem_added(object->get_signal<ModemAdded>()),
1545
282
          modem_removed(object->get_signal<ModemRemoved>())
1546
283
    {
1547
284
        auto result = object->invoke_method_synchronously<GetModems, GetModems::ResultType>();
1548
285
1549
286
        if (result.is_error())
1550
287
            connectivity::throw_dbus_exception(result.error());
1551
288
1552
289
        for (const auto& element : result.value())
1553
290
        {
1554
291
            modems.insert(
1555
292
                        std::make_pair(
1556
293
                            element.value,
1557
294
                            Modem
1558
295
                            {
1559
296
                                service,
1560
297
                                service->object_for_path(element.value)
1561
298
                            }));
1562
299
        }
1563
300
1564
301
        modem_added->connect([this](const ModemAdded::ArgumentType& arg)
1565
302
        {
1566
303
            std::lock_guard<std::mutex> lg(guard);
1567
304
            modems.insert(
1568
305
                        std::make_pair(
1569
306
                            std::get<0>(arg),
1570
307
                            Modem{
1571
308
                                service,
1572
309
                                service->object_for_path(std::get<0>(arg))
1573
310
                            }));
1574
311
        });
1575
312
1576
313
        modem_removed->connect([this](const ModemRemoved::ArgumentType& arg)
1577
314
        {
1578
315
            std::lock_guard<std::mutex> lg(guard);
1579
316
            modems.erase(arg);
1580
317
        });
1581
318
    }
1582
319
1583
320
    void for_each_modem(const std::function<void(const Modem&)>& functor) const
1584
321
    {
1585
322
        std::lock_guard<std::mutex> lg(guard);
1586
323
        for (const auto& modem : modems)
1587
324
        {
1588
325
            functor(modem.second);
1589
326
        }
1590
327
    }
1591
328
1592
329
    std::shared_ptr<core::dbus::Service> service;
1593
330
    std::shared_ptr<core::dbus::Object> object;
1594
331
    std::shared_ptr<core::dbus::Signal<ModemAdded, ModemAdded::ArgumentType>> modem_added;
1595
332
    std::shared_ptr<core::dbus::Signal<ModemRemoved, ModemRemoved::ArgumentType>> modem_removed;
1596
333
    mutable std::mutex guard;
1597
334
    std::map<core::dbus::types::ObjectPath, Modem> modems;
1598
335
};
1599
336
};
1600
337
}
1601
338
1602
339
#endif // LOCATION_SERVICE_LOCATION_CONNECTIVITY_OFONO_H
1603
340
0
1604
=== removed file 'dbus-cpp/services/urfkill.h'
1605
--- dbus-cpp/services/urfkill.h	2014-05-30 13:18:36 +0000
1606
+++ dbus-cpp/services/urfkill.h	1970-01-01 00:00:00 +0000
1607
@@ -1,338 +0,0 @@
1608
1
/*
1609
2
 * Copyright © 2014 Canonical Ltd.
1610
3
 *
1611
4
 * This program is free software: you can redistribute it and/or modify it
1612
5
 * under the terms of the GNU Lesser General Public License version 3,
1613
6
 * as published by the Free Software Foundation.
1614
7
 *
1615
8
 * This program is distributed in the hope that it will be useful,
1616
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1617
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1618
11
 * GNU Lesser General Public License for more details.
1619
12
 *
1620
13
 * You should have received a copy of the GNU Lesser General Public License
1621
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1622
15
 *
1623
16
 * Authored by: Antti Kaijanmäki <antti.kaijanmaki@canonical.com>
1624
17
 */
1625
18
#ifndef PLATFORM_MANAGER_NMOFONO_URFKILL_H
1626
19
#define PLATFORM_MANAGER_NMOFONO_URFKILL_H
1627
20
1628
21
#include <core/dbus/bus.h>
1629
22
#include <core/dbus/object.h>
1630
23
#include <core/dbus/property.h>
1631
24
#include <core/dbus/service.h>
1632
25
#include <core/dbus/types/object_path.h>
1633
26
#include <core/dbus/types/any.h>
1634
27
#include <core/dbus/types/struct.h>
1635
28
#include <core/dbus/types/stl/map.h>
1636
29
#include <core/dbus/types/stl/string.h>
1637
30
#include <core/dbus/types/stl/tuple.h>
1638
31
#include <core/dbus/types/stl/vector.h>
1639
32
#include "util.h"
1640
33
1641
34
namespace org
1642
35
{
1643
36
namespace freedesktop
1644
37
{
1645
38
namespace URfkill
1646
39
{
1647
40
1648
41
struct Interface
1649
42
{
1650
43
    struct Killswitch
1651
44
    {
1652
45
        static const std::string& name()
1653
46
        {
1654
47
            static const std::string s{"org.freedesktop.URfkill.Killswitch"};
1655
48
            return s;
1656
49
        }
1657
50
1658
51
        struct Property
1659
52
        {
1660
53
            struct State
1661
54
            {
1662
55
                static const std::string& name()
1663
56
                {
1664
57
                    static const std::string s{"state"};
1665
58
                    return s;
1666
59
                }
1667
60
1668
61
                typedef Killswitch Interface;
1669
62
                typedef std::int32_t ValueType;
1670
63
                static const bool readable = true;
1671
64
                static const bool writable = false;
1672
65
            };
1673
66
        };
1674
67
1675
68
        enum class Type;
1676
69
        Killswitch(const std::shared_ptr<core::dbus::Object>& object,
1677
70
                   Type type)
1678
71
            : object(object),
1679
72
              type(type),
1680
73
              _state(object->get_property<Property::State>())
1681
74
        {
1682
75
            _state->changed().connect(std::bind(&Killswitch::_stateChanged, this, std::placeholders::_1));
1683
76
            _stateChanged(_state->get());
1684
77
        }
1685
78
1686
79
        enum class State
1687
80
        {
1688
81
            not_available = -1,
1689
82
            unblocked = 0,
1690
83
            soft_blocked = 1,
1691
84
            hard_blocked = 2
1692
85
        };
1693
86
1694
87
        enum class Type {
1695
88
            bluetooth,
1696
89
            fm,
1697
90
            gps,
1698
91
            nfc,
1699
92
            uwb,
1700
93
            wimax,
1701
94
            wlan,
1702
95
            wwan
1703
96
        };
1704
97
1705
98
        static const std::string path(Type type)
1706
99
        {
1707
100
            switch(type) {
1708
101
            case Type::bluetooth:
1709
102
                return "/org/freedesktop/URfkill/BLUETOOTH";
1710
103
            case Type::fm:
1711
104
                return "/org/freedesktop/URfkill/FM";
1712
105
            case Type::gps:
1713
106
                return "/org/freedesktop/URfkill/GPS";
1714
107
            case Type::nfc:
1715
108
                return "/org/freedesktop/URfkill/NFC";
1716
109
            case Type::uwb:
1717
110
                return "/org/freedesktop/URfkill/UWB";
1718
111
            case Type::wimax:
1719
112
                return "/org/freedesktop/URfkill/WIMAX";
1720
113
            case Type::wlan:
1721
114
                return "/org/freedesktop/URfkill/WLAN";
1722
115
            case Type::wwan:
1723
116
                return "/org/freedesktop/URfkill/WWAN";
1724
117
            }
1725
118
1726
119
            return "";
1727
120
        }
1728
121
1729
122
        void _stateChanged(Property::State::ValueType val)
1730
123
        {
1731
124
            if (val == -1)
1732
125
                state.set(State::not_available);
1733
126
            else if (val == 0)
1734
127
                state.set(State::unblocked);
1735
128
            else if (val == 1)
1736
129
                state.set(State::soft_blocked);
1737
130
            else if (val == 2)
1738
131
                state.set(State::hard_blocked);
1739
132
            else
1740
133
                throw std::runtime_error("got unknown Killswitch state from urfkill: " + std::to_string(val));
1741
134
        }
1742
135
1743
136
        std::shared_ptr<core::dbus::Object> object;
1744
137
        const Type type;
1745
138
        std::shared_ptr<core::dbus::Property<Property::State>> _state;
1746
139
        core::Property<State> state;
1747
140
    };
1748
141
1749
142
    struct URfkill
1750
143
    {
1751
144
        static const std::string& name()
1752
145
        {
1753
146
            static const std::string s{"org.freedesktop.URfkill"};
1754
147
            return s;
1755
148
        }
1756
149
1757
150
        struct Method
1758
151
        {
1759
152
            struct Block
1760
153
            {
1761
154
                static const std::string& name()
1762
155
                {
1763
156
                    static const std::string s{"Block"};
1764
157
                    return s;
1765
158
                }
1766
159
1767
160
                typedef URfkill Interface;
1768
161
                typedef bool ResultType;
1769
162
1770
163
                static std::chrono::milliseconds default_timeout()
1771
164
                {
1772
165
                    return std::chrono::seconds{5};
1773
166
                }
1774
167
            };
1775
168
1776
169
            struct FlightMode
1777
170
            {
1778
171
                static const std::string& name()
1779
172
                {
1780
173
                    static const std::string s{"FlightMode"};
1781
174
                    return s;
1782
175
                }
1783
176
1784
177
                typedef URfkill Interface;
1785
178
                typedef bool ResultType;
1786
179
1787
180
                static std::chrono::milliseconds default_timeout()
1788
181
                {
1789
182
                    return std::chrono::seconds{5};
1790
183
                }
1791
184
            };
1792
185
1793
186
            struct IsFlightMode
1794
187
            {
1795
188
                static const std::string& name()
1796
189
                {
1797
190
                    static const std::string s{"IsFlightMode"};
1798
191
                    return s;
1799
192
                }
1800
193
1801
194
                typedef URfkill Interface;
1802
195
                typedef bool ResultType;
1803
196
1804
197
                static std::chrono::milliseconds default_timeout()
1805
198
                {
1806
199
                    return std::chrono::seconds{1};
1807
200
                }
1808
201
            };
1809
202
        };
1810
203
1811
204
        struct Signal
1812
205
        {
1813
206
            struct FlightModeChanged
1814
207
            {
1815
208
                static const std::string& name()
1816
209
                {
1817
210
                    static const std::string s{"FlightModeChanged"};
1818
211
                    return s;
1819
212
                }
1820
213
1821
214
                typedef URfkill Interface;
1822
215
                typedef bool ArgumentType;
1823
216
            };
1824
217
        };
1825
218
1826
219
        URfkill(std::shared_ptr<core::dbus::Service> &service,
1827
220
                std::shared_ptr<core::dbus::Object> &object)
1828
221
            : service{service},
1829
222
              object{object},
1830
223
              flightModeChanged{object->get_signal<Signal::FlightModeChanged>()}
1831
224
        {
1832
225
            switches[Killswitch::Type::bluetooth] = std::make_shared<Killswitch>(service->object_for_path(Killswitch::path(Killswitch::Type::bluetooth)), Killswitch::Type::bluetooth);
1833
226
            switches[Killswitch::Type::fm]        = std::make_shared<Killswitch>(service->object_for_path(Killswitch::path(Killswitch::Type::fm)),        Killswitch::Type::fm);
1834
227
            switches[Killswitch::Type::gps]       = std::make_shared<Killswitch>(service->object_for_path(Killswitch::path(Killswitch::Type::gps)),       Killswitch::Type::gps);
1835
228
            switches[Killswitch::Type::nfc]       = std::make_shared<Killswitch>(service->object_for_path(Killswitch::path(Killswitch::Type::nfc)),       Killswitch::Type::nfc);
1836
229
            switches[Killswitch::Type::uwb]       = std::make_shared<Killswitch>(service->object_for_path(Killswitch::path(Killswitch::Type::uwb)),       Killswitch::Type::uwb);
1837
230
            switches[Killswitch::Type::wimax]     = std::make_shared<Killswitch>(service->object_for_path(Killswitch::path(Killswitch::Type::wimax)),     Killswitch::Type::wimax);
1838
231
            switches[Killswitch::Type::wlan]      = std::make_shared<Killswitch>(service->object_for_path(Killswitch::path(Killswitch::Type::wlan)),      Killswitch::Type::wlan);
1839
232
            switches[Killswitch::Type::wwan]      = std::make_shared<Killswitch>(service->object_for_path(Killswitch::path(Killswitch::Type::wwan)),      Killswitch::Type::wwan);
1840
233
        }
1841
234
1842
235
        bool block(Killswitch::Type type, bool block)
1843
236
        {
1844
237
            std::uint32_t utype;
1845
238
            switch (type) {
1846
239
            case Killswitch::Type::bluetooth:
1847
240
                utype = 2;
1848
241
                break;
1849
242
            case Killswitch::Type::fm:
1850
243
                utype = 7;
1851
244
                break;
1852
245
            case Killswitch::Type::gps:
1853
246
                utype = 6;
1854
247
                break;
1855
248
            case Killswitch::Type::nfc:
1856
249
                utype = 8; /// @todo verify me
1857
250
                break;
1858
251
            case Killswitch::Type::uwb:
1859
252
                utype = 3;
1860
253
                break;
1861
254
            case Killswitch::Type::wimax:
1862
255
                utype = 4;
1863
256
                break;
1864
257
            case Killswitch::Type::wlan:
1865
258
                utype = 1;
1866
259
                break;
1867
260
            case Killswitch::Type::wwan:
1868
261
                utype = 5;
1869
262
                break;
1870
263
            }
1871
264
            // we can't handle "all" (0) with this, but that's deprecated by FlightMode anyway
1872
265
1873
266
            auto result =
1874
267
                    object->invoke_method_synchronously<
1875
268
                       Method::Block, Method::Block::ResultType>
1876
269
                    (utype, block);
1877
270
1878
271
            if (result.is_error())
1879
272
                throw std::runtime_error(result.error().print());
1880
273
1881
274
            return result.value();
1882
275
        }
1883
276
1884
277
        bool flightMode(bool block)
1885
278
        {
1886
279
            auto result =
1887
280
                    object->invoke_method_synchronously<
1888
281
                       Method::FlightMode, Method::FlightMode::ResultType>
1889
282
                    (block);
1890
283
1891
284
            if (result.is_error())
1892
285
                throw std::runtime_error(result.error().print());
1893
286
1894
287
            return result.value();
1895
288
        }
1896
289
1897
290
        bool isFlightMode()
1898
291
        {
1899
292
            auto result =
1900
293
                    object->invoke_method_synchronously<
1901
294
                       Method::IsFlightMode, Method::IsFlightMode::ResultType>
1902
295
                    ();
1903
296
1904
297
            if (result.is_error())
1905
298
                throw std::runtime_error(result.error().print());
1906
299
1907
300
            return result.value();
1908
301
        }
1909
302
1910
303
        std::shared_ptr<core::dbus::Service> service;
1911
304
        std::shared_ptr<core::dbus::Object> object;
1912
305
        std::shared_ptr<core::dbus::Signal<Signal::FlightModeChanged, Signal::FlightModeChanged::ArgumentType>> flightModeChanged;
1913
306
1914
307
        std::map<Killswitch::Type, std::shared_ptr<Killswitch>> switches;
1915
308
    };
1916
309
};
1917
310
1918
311
struct Service
1919
312
{
1920
313
    std::shared_ptr<Interface::URfkill> urfkill;
1921
314
1922
315
    Service(const core::dbus::Bus::Ptr& bus)
1923
316
    {
1924
317
        auto service = core::dbus::Service::use_service<Interface::URfkill>(bus);
1925
318
        auto object = service->object_for_path(core::dbus::types::ObjectPath("/org/freedesktop/URfkill"));
1926
319
        urfkill = std::make_shared<Interface::URfkill>(service, object);
1927
320
    }
1928
321
1929
322
    struct Mock
1930
323
    {
1931
324
        std::shared_ptr<Interface::URfkill> urfkill;
1932
325
1933
326
        Mock(const core::dbus::Bus::Ptr& bus)
1934
327
        {
1935
328
            auto service = core::dbus::Service::add_service<Interface::URfkill>(bus);
1936
329
            auto object = service->add_object_for_path(core::dbus::types::ObjectPath("/org/freedesktop/URfkill"));
1937
330
            urfkill = std::make_shared<Interface::URfkill>(service, object);
1938
331
        }
1939
332
    };
1940
333
};
1941
334
}
1942
335
}
1943
336
}
1944
337
1945
338
#endif // PLATFORM_MANAGER_NMOFONO_URFKILL_H
1946
339
0
1947
=== removed file 'dbus-cpp/services/util.h'
1948
--- dbus-cpp/services/util.h	2014-04-23 13:27:07 +0000
1949
+++ dbus-cpp/services/util.h	1970-01-01 00:00:00 +0000
1950
@@ -1,36 +0,0 @@
1951
1
/*
1952
2
 * Copyright © 2013 Canonical Ltd.
1953
3
 *
1954
4
 * This program is free software: you can redistribute it and/or modify it
1955
5
 * under the terms of the GNU Lesser General Public License version 3,
1956
6
 * as published by the Free Software Foundation.
1957
7
 *
1958
8
 * This program is distributed in the hope that it will be useful,
1959
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1960
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1961
11
 * GNU Lesser General Public License for more details.
1962
12
 *
1963
13
 * You should have received a copy of the GNU Lesser General Public License
1964
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1965
15
 *
1966
16
 * Authors:
1967
17
 *     Jussi Pakkanen <jussi.pakkanen@canonical.com>
1968
18
 */
1969
19
1970
20
#ifndef CONNECTIVITY_UTIL_H
1971
21
#define CONNECTIVITY_UTIL_H
1972
22
1973
23
namespace core {
1974
24
namespace dbus {
1975
25
class Error;
1976
26
}
1977
27
}
1978
28
1979
29
namespace connectivity {
1980
30
1981
31
void throw_dbus_exception(const core::dbus::Error &e);
1982
32
1983
33
}
1984
34
1985
35
1986
36
#endif
1987
37
0
1988
=== added file 'debian/connectivity-doc.install'
1989
--- debian/connectivity-doc.install	1970-01-01 00:00:00 +0000
1990
+++ debian/connectivity-doc.install	2014-08-21 18:21:03 +0000
1991
@@ -0,0 +1,1 @@
1992
1
usr/share/doc/connectivity-api/*
1993
0
2
1994
=== modified file 'debian/control'
1995
--- debian/control	2014-07-22 19:54:24 +0000
1996
+++ debian/control	2014-08-21 18:21:03 +0000
1997
@@ -3,7 +3,7 @@
1998
3
Section: libs
3
Section: libs
1999
4
Maintainer: Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
4
Maintainer: Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
2000
5
Build-Depends: cmake,
5
Build-Depends: cmake,
2002
6
               dbus,
6
               dbus-test-runner,
2003
7
               debhelper (>= 9),
7
               debhelper (>= 9),
2004
8
               doxygen,
8
               doxygen,
2005
9
               google-mock,
9
               google-mock,
2006
@@ -13,44 +13,63 @@
2007
13
# version.
13
# version.
2008
14
               g++-4.9,
14
               g++-4.9,
2009
15
               lcov,
15
               lcov,
2010
16
               libdbus-1-dev,
2011
17
               libdbus-cpp-dev (>= 4.0.0),
2012
18
               libgtest-dev,
16
               libgtest-dev,
2013
19
               libprocess-cpp-dev,
2014
20
               libproperties-cpp-dev,
2015
21
               network-manager-dev,
2016
22
               pkg-config,
17
               pkg-config,
2017
18
               qt5-default,
2018
19
               qtbase5-dev,
2019
20
               qtbase5-dev-tools,
2020
21
               qtdeclarative5-dev,
2021
22
               qtdeclarative5-dev-tools,
2022
23
               qml-module-qtquick2,
2023
24
               qml-module-qttest,
2024
23
Standards-Version: 3.9.5
25
Standards-Version: 3.9.5
2025
24
Homepage: https://launchpad.net/connectivity-api
26
Homepage: https://launchpad.net/connectivity-api
2026
25
Vcs-Bzr: lp:connectivity-api
27
Vcs-Bzr: lp:connectivity-api
2027
26
Vcs-Browser: https://bazaar.launchpad.net/~unity-api-team/connectivity-api/trunk.14.04/files
28
Vcs-Browser: https://bazaar.launchpad.net/~unity-api-team/connectivity-api/trunk.14.04/files
2028
27
29
2030
28
Package: libconnectivity-cpp0
30
Package: libconnectivity-qt1
2031
29
Architecture: any
31
Architecture: any
2032
32
Pre-Depends: ${misc:Pre-Depends}
2033
30
Multi-Arch: same
33
Multi-Arch: same
2041
31
Pre-Depends: ${misc:Pre-Depends}
34
Depends: ${misc:Depends},
2042
32
Depends: ${shlibs:Depends},
35
         ${shlibs:Depends},
2043
33
         ${misc:Depends},
36
         indicator-network (>= 0.5.1+14.10.20140819),
2044
34
         network-manager,
37
Description: Ubuntu Connectivity Qt API
2045
35
#         urfkill,
38
 Ubuntu Connectivity API - Qt bindings
2039
36
Description: C++11 library providing connectivity API.
2040
37
 Connectivity API provides information on system networking.
2046
38
39
2048
39
Package: libconnectivity-cpp-dev
40
Package: libconnectivity-qt1-dev
2049
40
Section: libdevel
41
Section: libdevel
2050
41
Architecture: any
42
Architecture: any
2061
42
Multi-Arch: same
43
Pre-Depends: ${misc:Pre-Depends}
2062
43
Depends: ${misc:Depends},
44
Multi-Arch: same
2063
44
         libconnectivity-cpp0 (= ${binary:Version}),
45
Depends: ${misc:Depends},
2064
45
         libdbus-cpp-dev,
46
         ${shlibs:Depends},
2065
46
         libproperties-cpp-dev,
47
         libconnectivity-qt1 (= ${binary:Version}),
2066
47
Suggests: libconnectivity-cpp-doc
48
         qtbase5-dev
2067
48
Description: C++11 library providing connectivity API. - dev headers
49
Suggests: connectivity-doc,
2068
49
 All the development headers and libraries for libconnectivity-cpp.
50
Description: Ubuntu Connectivity Qt API - development files
2069
50
51
 Ubuntu Connectivity API - Qt bindings
2070
51
Package: libconnectivity-cpp-doc
52
 .
2071
53
 This package contains development files to develop against the Qt library.
2072
54
2073
55
Package: qml-module-ubuntu-connectivity
2074
56
Architecture: any
2075
57
Pre-Depends: ${misc:Pre-Depends}
2076
58
Multi-Arch: same
2077
59
Depends: ${misc:Depends},
2078
60
         ${shlibs:Depends},
2079
61
         libconnectivity-qt1 (= ${binary:Version}),
2080
62
Description: Ubuntu Connectivity API QML Components
2081
63
 Ubuntu Connectivity API - QML bindings
2082
64
 .
2083
65
 This package contains the qtdeclarative bindings for Ubuntu connectivity API.
2084
66
2085
67
Package: connectivity-doc
2086
52
Section: doc
68
Section: doc
2087
53
Architecture: all
69
Architecture: all
2088
54
Depends: ${misc:Depends},
70
Depends: ${misc:Depends},
2091
55
Description: Documentation files for libconnectivity-cpp-dev
71
         ${shlibs:Depends},
2092
56
 Documentation files for the libconnectivity-cpp development.
72
Description: Unity Action API - documentation
2093
73
 Ubuntu Connectivity API
2094
74
 .
2095
75
 This package contains developer documentation.
2096
57
76
2097
=== removed file 'debian/libconnectivity-cpp-dev.install'
2098
--- debian/libconnectivity-cpp-dev.install	2014-01-23 22:09:36 +0000
2099
+++ debian/libconnectivity-cpp-dev.install	1970-01-01 00:00:00 +0000
2100
@@ -1,3 +0,0 @@
2101
1
usr/include/*
2102
2
usr/lib/*/*.so
2103
3
usr/lib/pkgconfig/*
2104
4
\ No newline at end of file
0
\ No newline at end of file
2105
5
1
2106
=== removed file 'debian/libconnectivity-cpp-doc.install'
2107
--- debian/libconnectivity-cpp-doc.install	2014-01-23 22:09:36 +0000
2108
+++ debian/libconnectivity-cpp-doc.install	1970-01-01 00:00:00 +0000
2109
@@ -1,1 +0,0 @@
2110
1
usr/share/doc/connectivity-cpp/
2111
2
\ No newline at end of file
0
\ No newline at end of file
2112
3
1
2113
=== removed file 'debian/libconnectivity-cpp0.install'
2114
--- debian/libconnectivity-cpp0.install	2014-03-11 21:08:34 +0000
2115
+++ debian/libconnectivity-cpp0.install	1970-01-01 00:00:00 +0000
2116
@@ -1,1 +0,0 @@
2117
1
usr/lib/*/*.so.*
2118
2
0
2119
=== added file 'debian/libconnectivity-qt1-dev.install'
2120
--- debian/libconnectivity-qt1-dev.install	1970-01-01 00:00:00 +0000
2121
+++ debian/libconnectivity-qt1-dev.install	2014-08-21 18:21:03 +0000
2122
@@ -0,0 +1,3 @@
2123
1
usr/lib/*/libconnectivity-qt1.so
2124
2
usr/include/*
2125
3
usr/lib/*/pkgconfig/*
2126
0
4
2127
=== added file 'debian/libconnectivity-qt1.install'
2128
--- debian/libconnectivity-qt1.install	1970-01-01 00:00:00 +0000
2129
+++ debian/libconnectivity-qt1.install	2014-08-21 18:21:03 +0000
2130
@@ -0,0 +1,1 @@
2131
1
usr/lib/*/libconnectivity-qt1.so.*
2132
0
2
2133
=== added file 'debian/qml-module-ubuntu-connectivity.install'
2134
--- debian/qml-module-ubuntu-connectivity.install	1970-01-01 00:00:00 +0000
2135
+++ debian/qml-module-ubuntu-connectivity.install	2014-08-21 18:21:03 +0000
2136
@@ -0,0 +1,1 @@
2137
1
usr/lib/*/qt5/qml
2138
0
2
2139
=== added directory 'doc'
2140
=== removed directory 'doc'
2141
=== added file 'doc/CMakeLists.txt'
2142
--- doc/CMakeLists.txt	1970-01-01 00:00:00 +0000
2143
+++ doc/CMakeLists.txt	2014-08-21 18:21:03 +0000
2144
@@ -0,0 +1,27 @@
2145
1
set(INSTALL_DOCDIR ${CMAKE_INSTALL_DATAROOTDIR}/doc/connectivity-api)
2146
2
2147
3
if(build_type_lower MATCHES debug)
2148
4
    option(BUILD_DOC "Build documentation by default" FALSE)
2149
5
else()
2150
6
    option(BUILD_DOC "Build documentation by default" TRUE)
2151
7
endif()
2152
8
option(PRIVATE_DOCS "Build private documentation" FALSE)
2153
9
2154
10
if(${BUILD_DOC})
2155
11
    set(IS_ALL ALL)
2156
12
endif()
2157
13
2158
14
add_subdirectory(qt)
2159
15
set(DBUS_FILES
2160
16
    dbus/connectivity-api.txt
2161
17
)
2162
18
2163
19
add_custom_target(doc ${IS_ALL}
2164
20
    SOURCES ${DBUS_FILES}
2165
21
)
2166
22
add_dependencies(doc cppdoc qmldoc)
2167
23
2168
24
install(
2169
25
    DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/dbus/
2170
26
    DESTINATION ${INSTALL_DOCDIR}/dbus/
2171
27
)
2172
0
28
2173
=== removed file 'doc/CMakeLists.txt'
2174
--- doc/CMakeLists.txt	2014-03-13 15:33:18 +0000
2175
+++ doc/CMakeLists.txt	1970-01-01 00:00:00 +0000
2176
@@ -1,65 +0,0 @@
2177
1
# Copyright © 2013 Canonical Ltd.
2178
2
#
2179
3
# This program is free software: you can redistribute it and/or modify it
2180
4
# under the terms of the GNU Lesser General Public License version 3,
2181
5
# as published by the Free Software Foundation.
2182
6
#
2183
7
# This program is distributed in the hope that it will be useful,
2184
8
# but WITHOUT ANY WARRANTY; without even the implied warranty of
2185
9
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2186
10
# GNU Lesser General Public License for more details.
2187
11
#
2188
12
# You should have received a copy of the GNU Lesser General Public License
2189
13
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
2190
14
#
2191
15
# Authors:
2192
16
#     Antti Kaijanmäki <antti.kaijanmaki@canonical.com>
2193
17
2194
18
string(TOLOWER "${CMAKE_BUILD_TYPE}" typelower)
2195
19
set(EXTRACT_PRIVATE NO)
2196
20
set(INTERNAL_DOCS NO)
2197
21
set(SOURCE_DIRS "${CMAKE_SOURCE_DIR}/include ${CMAKE_CURRENT_SOURCE_DIR}")
2198
22
2199
23
if("${typelower}" STREQUAL "debug")
2200
24
  option(BUILD_DOC "Build documentation by default" FALSE)
2201
25
else()
2202
26
  option(BUILD_DOC "Build documentation by default" TRUE)
2203
27
endif()
2204
28
2205
29
option(PRIVATE_DOCS "Build private documentation" FALSE)
2206
30
2207
31
find_package(Doxygen)
2208
32
2209
33
if(${BUILD_DOC})
2210
34
  set(IS_ALL ALL)
2211
35
endif()
2212
36
if(${PRIVATE_DOCS})
2213
37
  set(EXTRACT_PRIVATE YES)
2214
38
  set(INTERNAL_DOCS YES)
2215
39
  set(SOURCE_DIRS "${SOURCE_DIRS} ${CMAKE_SOURCE_DIR}/src ${CMAKE_SOURCE_DIR}/dbus")
2216
40
endif()
2217
41
2218
42
if (DOXYGEN_FOUND)
2219
43
  configure_file(
2220
44
    ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in 
2221
45
    ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY)
2222
46
  add_custom_target(doc ${IS_ALL}
2223
47
    ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
2224
48
    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
2225
49
    COMMENT "Generating API documentation with Doxygen" VERBATIM)
2226
50
  install(
2227
51
    DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html
2228
52
    DESTINATION ${CMAKE_INSTALL_DOCDIR})
2229
53
  install(
2230
54
    DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/xml
2231
55
    DESTINATION ${CMAKE_INSTALL_DOCDIR})
2232
56
2233
57
endif (DOXYGEN_FOUND)
2234
58
2235
59
# list these here to have them visible in Qt Creator
2236
60
set(DOC_PAGES
2237
61
    pages/mainpage.dox
2238
62
    pages/using.dox
2239
63
    pages/networking-status.dox
2240
64
)
2241
65
add_custom_target(QtCreatorDocsHack SOURCES ${DOC_PAGES})
2242
66
0
2243
=== removed file 'doc/Doxyfile.in'
2244
--- doc/Doxyfile.in	2014-03-13 15:33:18 +0000
2245
+++ doc/Doxyfile.in	1970-01-01 00:00:00 +0000
2246
@@ -1,1869 +0,0 @@
2247
1
# Doxyfile 1.8.3.1
2248
2
2249
3
# This file describes the settings to be used by the documentation system
2250
4
# doxygen (www.doxygen.org) for a project.
2251
5
#
2252
6
# All text after a hash (#) is considered a comment and will be ignored.
2253
7
# The format is:
2254
8
#       TAG = value [value, ...]
2255
9
# For lists items can also be appended using:
2256
10
#       TAG += value [value, ...]
2257
11
# Values that contain spaces should be placed between quotes (" ").
2258
12
2259
13
#---------------------------------------------------------------------------
2260
14
# Project related configuration options
2261
15
#---------------------------------------------------------------------------
2262
16
2263
17
# This tag specifies the encoding used for all characters in the config file
2264
18
# that follow. The default is UTF-8 which is also the encoding used for all
2265
19
# text before the first occurrence of this tag. Doxygen uses libiconv (or the
2266
20
# iconv built into libc) for the transcoding. See
2267
21
# http://www.gnu.org/software/libiconv for the list of possible encodings.
2268
22
2269
23
DOXYFILE_ENCODING      = UTF-8
2270
24
2271
25
# The PROJECT_NAME tag is a single word (or sequence of words) that should
2272
26
# identify the project. Note that if you do not use Doxywizard you need
2273
27
# to put quotes around the project name if it contains spaces.
2274
28
2275
29
PROJECT_NAME           = @CMAKE_PROJECT_NAME@
2276
30
2277
31
# The PROJECT_NUMBER tag can be used to enter a project or revision number.
2278
32
# This could be handy for archiving the generated documentation or
2279
33
# if some version control system is used.
2280
34
2281
35
PROJECT_NUMBER         = @CONNECTIVITY_CPP_VERSION_MAJOR@.@CONNECTIVITY_CPP_VERSION_MINOR@.@CONNECTIVITY_CPP_VERSION_PATCH@
2282
36
2283
37
# Using the PROJECT_BRIEF tag one can provide an optional one line description
2284
38
# for a project that appears at the top of each page and should give viewer
2285
39
# a quick idea about the purpose of the project. Keep the description short.
2286
40
2287
41
PROJECT_BRIEF          =
2288
42
2289
43
# With the PROJECT_LOGO tag one can specify an logo or icon that is
2290
44
# included in the documentation. The maximum height of the logo should not
2291
45
# exceed 55 pixels and the maximum width should not exceed 200 pixels.
2292
46
# Doxygen will copy the logo to the output directory.
2293
47
2294
48
PROJECT_LOGO           =
2295
49
2296
50
# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
2297
51
# base path where the generated documentation will be put.
2298
52
# If a relative path is entered, it will be relative to the location
2299
53
# where doxygen was started. If left blank the current directory will be used.
2300
54
2301
55
OUTPUT_DIRECTORY       =
2302
56
2303
57
# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
2304
58
# 4096 sub-directories (in 2 levels) under the output directory of each output
2305
59
# format and will distribute the generated files over these directories.
2306
60
# Enabling this option can be useful when feeding doxygen a huge amount of
2307
61
# source files, where putting all generated files in the same directory would
2308
62
# otherwise cause performance problems for the file system.
2309
63
2310
64
CREATE_SUBDIRS         = NO
2311
65
2312
66
# The OUTPUT_LANGUAGE tag is used to specify the language in which all
2313
67
# documentation generated by doxygen is written. Doxygen will use this
2314
68
# information to generate all constant output in the proper language.
2315
69
# The default language is English, other supported languages are:
2316
70
# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
2317
71
# Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German,
2318
72
# Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English
2319
73
# messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian,
2320
74
# Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic, Slovak,
2321
75
# Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
2322
76
2323
77
OUTPUT_LANGUAGE        = English
2324
78
2325
79
# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
2326
80
# include brief member descriptions after the members that are listed in
2327
81
# the file and class documentation (similar to JavaDoc).
2328
82
# Set to NO to disable this.
2329
83
2330
84
BRIEF_MEMBER_DESC      = YES
2331
85
2332
86
# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
2333
87
# the brief description of a member or function before the detailed description.
2334
88
# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
2335
89
# brief descriptions will be completely suppressed.
2336
90
2337
91
REPEAT_BRIEF           = YES
2338
92
2339
93
# This tag implements a quasi-intelligent brief description abbreviator
2340
94
# that is used to form the text in various listings. Each string
2341
95
# in this list, if found as the leading text of the brief description, will be
2342
96
# stripped from the text and the result after processing the whole list, is
2343
97
# used as the annotated text. Otherwise, the brief description is used as-is.
2344
98
# If left blank, the following values are used ("$name" is automatically
2345
99
# replaced with the name of the entity): "The $name class" "The $name widget"
2346
100
# "The $name file" "is" "provides" "specifies" "contains"
2347
101
# "represents" "a" "an" "the"
2348
102
2349
103
ABBREVIATE_BRIEF       =
2350
104
2351
105
# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
2352
106
# Doxygen will generate a detailed section even if there is only a brief
2353
107
# description.
2354
108
2355
109
ALWAYS_DETAILED_SEC    = NO
2356
110
2357
111
# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
2358
112
# inherited members of a class in the documentation of that class as if those
2359
113
# members were ordinary class members. Constructors, destructors and assignment
2360
114
# operators of the base classes will not be shown.
2361
115
2362
116
INLINE_INHERITED_MEMB  = NO
2363
117
2364
118
# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
2365
119
# path before files name in the file list and in the header files. If set
2366
120
# to NO the shortest path that makes the file name unique will be used.
2367
121
2368
122
FULL_PATH_NAMES        = No
2369
123
2370
124
# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
2371
125
# can be used to strip a user-defined part of the path. Stripping is
2372
126
# only done if one of the specified strings matches the left-hand part of
2373
127
# the path. The tag can be used to show relative paths in the file list.
2374
128
# If left blank the directory from which doxygen is run is used as the
2375
129
# path to strip. Note that you specify absolute paths here, but also
2376
130
# relative paths, which will be relative from the directory where doxygen is
2377
131
# started.
2378
132
2379
133
STRIP_FROM_PATH        =
2380
134
2381
135
# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
2382
136
# the path mentioned in the documentation of a class, which tells
2383
137
# the reader which header file to include in order to use a class.
2384
138
# If left blank only the name of the header file containing the class
2385
139
# definition is used. Otherwise one should specify the include paths that
2386
140
# are normally passed to the compiler using the -I flag.
2387
141
2388
142
STRIP_FROM_INC_PATH    = @CMAKE_SOURCE_DIR@/include
2389
143
2390
144
# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
2391
145
# (but less readable) file names. This can be useful if your file system
2392
146
# doesn't support long names like on DOS, Mac, or CD-ROM.
2393
147
2394
148
SHORT_NAMES            = NO
2395
149
2396
150
# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
2397
151
# will interpret the first line (until the first dot) of a JavaDoc-style
2398
152
# comment as the brief description. If set to NO, the JavaDoc
2399
153
# comments will behave just like regular Qt-style comments
2400
154
# (thus requiring an explicit @brief command for a brief description.)
2401
155
2402
156
JAVADOC_AUTOBRIEF      = NO
2403
157
2404
158
# If the QT_AUTOBRIEF tag is set to YES then Doxygen will
2405
159
# interpret the first line (until the first dot) of a Qt-style
2406
160
# comment as the brief description. If set to NO, the comments
2407
161
# will behave just like regular Qt-style comments (thus requiring
2408
162
# an explicit \brief command for a brief description.)
2409
163
2410
164
QT_AUTOBRIEF           = NO
2411
165
2412
166
# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
2413
167
# treat a multi-line C++ special comment block (i.e. a block of //! or ///
2414
168
# comments) as a brief description. This used to be the default behaviour.
2415
169
# The new default is to treat a multi-line C++ comment block as a detailed
2416
170
# description. Set this tag to YES if you prefer the old behaviour instead.
2417
171
2418
172
MULTILINE_CPP_IS_BRIEF = NO
2419
173
2420
174
# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
2421
175
# member inherits the documentation from any documented member that it
2422
176
# re-implements.
2423
177
2424
178
INHERIT_DOCS           = YES
2425
179
2426
180
# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
2427
181
# a new page for each member. If set to NO, the documentation of a member will
2428
182
# be part of the file/class/namespace that contains it.
2429
183
2430
184
SEPARATE_MEMBER_PAGES  = NO
2431
185
2432
186
# The TAB_SIZE tag can be used to set the number of spaces in a tab.
2433
187
# Doxygen uses this value to replace tabs by spaces in code fragments.
2434
188
2435
189
TAB_SIZE               = 4
2436
190
2437
191
# This tag can be used to specify a number of aliases that acts
2438
192
# as commands in the documentation. An alias has the form "name=value".
2439
193
# For example adding "sideeffect=\par Side Effects:\n" will allow you to
2440
194
# put the command \sideeffect (or @sideeffect) in the documentation, which
2441
195
# will result in a user-defined paragraph with heading "Side Effects:".
2442
196
# You can put \n's in the value part of an alias to insert newlines.
2443
197
2444
198
ALIASES                =
2445
199
2446
200
# This tag can be used to specify a number of word-keyword mappings (TCL only).
2447
201
# A mapping has the form "name=value". For example adding
2448
202
# "class=itcl::class" will allow you to use the command class in the
2449
203
# itcl::class meaning.
2450
204
2451
205
TCL_SUBST              =
2452
206
2453
207
# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
2454
208
# sources only. Doxygen will then generate output that is more tailored for C.
2455
209
# For instance, some of the names that are used will be different. The list
2456
210
# of all members will be omitted, etc.
2457
211
2458
212
OPTIMIZE_OUTPUT_FOR_C  = NO
2459
213
2460
214
# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
2461
215
# sources only. Doxygen will then generate output that is more tailored for
2462
216
# Java. For instance, namespaces will be presented as packages, qualified
2463
217
# scopes will look different, etc.
2464
218
2465
219
OPTIMIZE_OUTPUT_JAVA   = NO
2466
220
2467
221
# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
2468
222
# sources only. Doxygen will then generate output that is more tailored for
2469
223
# Fortran.
2470
224
2471
225
OPTIMIZE_FOR_FORTRAN   = NO
2472
226
2473
227
# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
2474
228
# sources. Doxygen will then generate output that is tailored for
2475
229
# VHDL.
2476
230
2477
231
OPTIMIZE_OUTPUT_VHDL   = NO
2478
232
2479
233
# Doxygen selects the parser to use depending on the extension of the files it
2480
234
# parses. With this tag you can assign which parser to use for a given
2481
235
# extension. Doxygen has a built-in mapping, but you can override or extend it
2482
236
# using this tag. The format is ext=language, where ext is a file extension,
2483
237
# and language is one of the parsers supported by doxygen: IDL, Java,
2484
238
# Javascript, CSharp, C, C++, D, PHP, Objective-C, Python, Fortran, VHDL, C,
2485
239
# C++. For instance to make doxygen treat .inc files as Fortran files (default
2486
240
# is PHP), and .f files as C (default is Fortran), use: inc=Fortran f=C. Note
2487
241
# that for custom extensions you also need to set FILE_PATTERNS otherwise the
2488
242
# files are not read by doxygen.
2489
243
2490
244
EXTENSION_MAPPING      =
2491
245
2492
246
# If MARKDOWN_SUPPORT is enabled (the default) then doxygen pre-processes all
2493
247
# comments according to the Markdown format, which allows for more readable
2494
248
# documentation. See http://daringfireball.net/projects/markdown/ for details.
2495
249
# The output of markdown processing is further processed by doxygen, so you
2496
250
# can mix doxygen, HTML, and XML commands with Markdown formatting.
2497
251
# Disable only in case of backward compatibilities issues.
2498
252
2499
253
MARKDOWN_SUPPORT       = YES
2500
254
2501
255
# When enabled doxygen tries to link words that correspond to documented classes,
2502
256
# or namespaces to their corresponding documentation. Such a link can be
2503
257
# prevented in individual cases by by putting a % sign in front of the word or
2504
258
# globally by setting AUTOLINK_SUPPORT to NO.
2505
259
2506
260
AUTOLINK_SUPPORT       = YES
2507
261
2508
262
# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
2509
263
# to include (a tag file for) the STL sources as input, then you should
2510
264
# set this tag to YES in order to let doxygen match functions declarations and
2511
265
# definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
2512
266
# func(std::string) {}). This also makes the inheritance and collaboration
2513
267
# diagrams that involve STL classes more complete and accurate.
2514
268
2515
269
BUILTIN_STL_SUPPORT    = YES
2516
270
2517
271
# If you use Microsoft's C++/CLI language, you should set this option to YES to
2518
272
# enable parsing support.
2519
273
2520
274
CPP_CLI_SUPPORT        = NO
2521
275
2522
276
# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.
2523
277
# Doxygen will parse them like normal C++ but will assume all classes use public
2524
278
# instead of private inheritance when no explicit protection keyword is present.
2525
279
2526
280
SIP_SUPPORT            = NO
2527
281
2528
282
# For Microsoft's IDL there are propget and propput attributes to indicate
2529
283
# getter and setter methods for a property. Setting this option to YES (the
2530
284
# default) will make doxygen replace the get and set methods by a property in
2531
285
# the documentation. This will only work if the methods are indeed getting or
2532
286
# setting a simple type. If this is not the case, or you want to show the
2533
287
# methods anyway, you should set this option to NO.
2534
288
2535
289
IDL_PROPERTY_SUPPORT   = YES
2536
290
2537
291
# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
2538
292
# tag is set to YES, then doxygen will reuse the documentation of the first
2539
293
# member in the group (if any) for the other members of the group. By default
2540
294
# all members of a group must be documented explicitly.
2541
295
2542
296
DISTRIBUTE_GROUP_DOC   = NO
2543
297
2544
298
# Set the SUBGROUPING tag to YES (the default) to allow class member groups of
2545
299
# the same type (for instance a group of public functions) to be put as a
2546
300
# subgroup of that type (e.g. under the Public Functions section). Set it to
2547
301
# NO to prevent subgrouping. Alternatively, this can be done per class using
2548
302
# the \nosubgrouping command.
2549
303
2550
304
SUBGROUPING            = YES
2551
305
2552
306
# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and
2553
307
# unions are shown inside the group in which they are included (e.g. using
2554
308
# @ingroup) instead of on a separate page (for HTML and Man pages) or
2555
309
# section (for LaTeX and RTF).
2556
310
2557
311
INLINE_GROUPED_CLASSES = NO
2558
312
2559
313
# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and
2560
314
# unions with only public data fields will be shown inline in the documentation
2561
315
# of the scope in which they are defined (i.e. file, namespace, or group
2562
316
# documentation), provided this scope is documented. If set to NO (the default),
2563
317
# structs, classes, and unions are shown on a separate page (for HTML and Man
2564
318
# pages) or section (for LaTeX and RTF).
2565
319
2566
320
INLINE_SIMPLE_STRUCTS  = NO
2567
321
2568
322
# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum
2569
323
# is documented as struct, union, or enum with the name of the typedef. So
2570
324
# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
2571
325
# with name TypeT. When disabled the typedef will appear as a member of a file,
2572
326
# namespace, or class. And the struct will be named TypeS. This can typically
2573
327
# be useful for C code in case the coding convention dictates that all compound
2574
328
# types are typedef'ed and only the typedef is referenced, never the tag name.
2575
329
2576
330
TYPEDEF_HIDES_STRUCT   = NO
2577
331
2578
332
# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to
2579
333
# determine which symbols to keep in memory and which to flush to disk.
2580
334
# When the cache is full, less often used symbols will be written to disk.
2581
335
# For small to medium size projects (<1000 input files) the default value is
2582
336
# probably good enough. For larger projects a too small cache size can cause
2583
337
# doxygen to be busy swapping symbols to and from disk most of the time
2584
338
# causing a significant performance penalty.
2585
339
# If the system has enough physical memory increasing the cache will improve the
2586
340
# performance by keeping more symbols in memory. Note that the value works on
2587
341
# a logarithmic scale so increasing the size by one will roughly double the
2588
342
# memory usage. The cache size is given by this formula:
2589
343
# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
2590
344
# corresponding to a cache size of 2^16 = 65536 symbols.
2591
345
2592
346
SYMBOL_CACHE_SIZE      = 0
2593
347
2594
348
# Similar to the SYMBOL_CACHE_SIZE the size of the symbol lookup cache can be
2595
349
# set using LOOKUP_CACHE_SIZE. This cache is used to resolve symbols given
2596
350
# their name and scope. Since this can be an expensive process and often the
2597
351
# same symbol appear multiple times in the code, doxygen keeps a cache of
2598
352
# pre-resolved symbols. If the cache is too small doxygen will become slower.
2599
353
# If the cache is too large, memory is wasted. The cache size is given by this
2600
354
# formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range is 0..9, the default is 0,
2601
355
# corresponding to a cache size of 2^16 = 65536 symbols.
2602
356
2603
357
LOOKUP_CACHE_SIZE      = 0
2604
358
2605
359
#---------------------------------------------------------------------------
2606
360
# Build related configuration options
2607
361
#---------------------------------------------------------------------------
2608
362
2609
363
# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
2610
364
# documentation are documented, even if no documentation was available.
2611
365
# Private class members and static file members will be hidden unless
2612
366
# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
2613
367
2614
368
EXTRACT_ALL            = YES
2615
369
2616
370
# If the EXTRACT_PRIVATE tag is set to YES all private members of a class
2617
371
# will be included in the documentation.
2618
372
2619
373
EXTRACT_PRIVATE        = @EXTRACT_PRIVATE@
2620
374
2621
375
# If the EXTRACT_PACKAGE tag is set to YES all members with package or internal
2622
376
# scope will be included in the documentation.
2623
377
2624
378
EXTRACT_PACKAGE        = NO
2625
379
2626
380
# If the EXTRACT_STATIC tag is set to YES all static members of a file
2627
381
# will be included in the documentation.
2628
382
2629
383
EXTRACT_STATIC         = YES
2630
384
2631
385
# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
2632
386
# defined locally in source files will be included in the documentation.
2633
387
# If set to NO only classes defined in header files are included.
2634
388
2635
389
EXTRACT_LOCAL_CLASSES  = YES
2636
390
2637
391
# This flag is only useful for Objective-C code. When set to YES local
2638
392
# methods, which are defined in the implementation section but not in
2639
393
# the interface are included in the documentation.
2640
394
# If set to NO (the default) only methods in the interface are included.
2641
395
2642
396
EXTRACT_LOCAL_METHODS  = NO
2643
397
2644
398
# If this flag is set to YES, the members of anonymous namespaces will be
2645
399
# extracted and appear in the documentation as a namespace called
2646
400
# 'anonymous_namespace{file}', where file will be replaced with the base
2647
401
# name of the file that contains the anonymous namespace. By default
2648
402
# anonymous namespaces are hidden.
2649
403
2650
404
EXTRACT_ANON_NSPACES   = NO
2651
405
2652
406
# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
2653
407
# undocumented members of documented classes, files or namespaces.
2654
408
# If set to NO (the default) these members will be included in the
2655
409
# various overviews, but no documentation section is generated.
2656
410
# This option has no effect if EXTRACT_ALL is enabled.
2657
411
2658
412
HIDE_UNDOC_MEMBERS     = NO
2659
413
2660
414
# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
2661
415
# undocumented classes that are normally visible in the class hierarchy.
2662
416
# If set to NO (the default) these classes will be included in the various
2663
417
# overviews. This option has no effect if EXTRACT_ALL is enabled.
2664
418
2665
419
HIDE_UNDOC_CLASSES     = NO
2666
420
2667
421
# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
2668
422
# friend (class|struct|union) declarations.
2669
423
# If set to NO (the default) these declarations will be included in the
2670
424
# documentation.
2671
425
2672
426
HIDE_FRIEND_COMPOUNDS  = YES
2673
427
2674
428
# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
2675
429
# documentation blocks found inside the body of a function.
2676
430
# If set to NO (the default) these blocks will be appended to the
2677
431
# function's detailed documentation block.
2678
432
2679
433
HIDE_IN_BODY_DOCS      = NO
2680
434
2681
435
# The INTERNAL_DOCS tag determines if documentation
2682
436
# that is typed after a \internal command is included. If the tag is set
2683
437
# to NO (the default) then the documentation will be excluded.
2684
438
# Set it to YES to include the internal documentation.
2685
439
2686
440
INTERNAL_DOCS          = @INTERNAL_DOCS@
2687
441
2688
442
# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
2689
443
# file names in lower-case letters. If set to YES upper-case letters are also
2690
444
# allowed. This is useful if you have classes or files whose names only differ
2691
445
# in case and if your file system supports case sensitive file names. Windows
2692
446
# and Mac users are advised to set this option to NO.
2693
447
2694
448
CASE_SENSE_NAMES       = YES
2695
449
2696
450
# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
2697
451
# will show members with their full class and namespace scopes in the
2698
452
# documentation. If set to YES the scope will be hidden.
2699
453
2700
454
HIDE_SCOPE_NAMES       = NO
2701
455
2702
456
# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
2703
457
# will put a list of the files that are included by a file in the documentation
2704
458
# of that file.
2705
459
2706
460
SHOW_INCLUDE_FILES     = YES
2707
461
2708
462
# If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen
2709
463
# will list include files with double quotes in the documentation
2710
464
# rather than with sharp brackets.
2711
465
2712
466
FORCE_LOCAL_INCLUDES   = NO
2713
467
2714
468
# If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
2715
469
# is inserted in the documentation for inline members.
2716
470
2717
471
INLINE_INFO            = YES
2718
472
2719
473
# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
2720
474
# will sort the (detailed) documentation of file and class members
2721
475
# alphabetically by member name. If set to NO the members will appear in
2722
476
# declaration order.
2723
477
2724
478
SORT_MEMBER_DOCS       = YES
2725
479
2726
480
# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
2727
481
# brief documentation of file, namespace and class members alphabetically
2728
482
# by member name. If set to NO (the default) the members will appear in
2729
483
# declaration order.
2730
484
2731
485
SORT_BRIEF_DOCS        = NO
2732
486
2733
487
# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen
2734
488
# will sort the (brief and detailed) documentation of class members so that
2735
489
# constructors and destructors are listed first. If set to NO (the default)
2736
490
# the constructors will appear in the respective orders defined by
2737
491
# SORT_MEMBER_DOCS and SORT_BRIEF_DOCS.
2738
492
# This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO
2739
493
# and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.
2740
494
2741
495
SORT_MEMBERS_CTORS_1ST = NO
2742
496
2743
497
# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the
2744
498
# hierarchy of group names into alphabetical order. If set to NO (the default)
2745
499
# the group names will appear in their defined order.
2746
500
2747
501
SORT_GROUP_NAMES       = NO
2748
502
2749
503
# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
2750
504
# sorted by fully-qualified names, including namespaces. If set to
2751
505
# NO (the default), the class list will be sorted only by class name,
2752
506
# not including the namespace part.
2753
507
# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
2754
508
# Note: This option applies only to the class list, not to the
2755
509
# alphabetical list.
2756
510
2757
511
SORT_BY_SCOPE_NAME     = NO
2758
512
2759
513
# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to
2760
514
# do proper type resolution of all parameters of a function it will reject a
2761
515
# match between the prototype and the implementation of a member function even
2762
516
# if there is only one candidate or it is obvious which candidate to choose
2763
517
# by doing a simple string match. By disabling STRICT_PROTO_MATCHING doxygen
2764
518
# will still accept a match between prototype and implementation in such cases.
2765
519
2766
520
STRICT_PROTO_MATCHING  = NO
2767
521
2768
522
# The GENERATE_TODOLIST tag can be used to enable (YES) or
2769
523
# disable (NO) the todo list. This list is created by putting \todo
2770
524
# commands in the documentation.
2771
525
2772
526
GENERATE_TODOLIST      = YES
2773
527
2774
528
# The GENERATE_TESTLIST tag can be used to enable (YES) or
2775
529
# disable (NO) the test list. This list is created by putting \test
2776
530
# commands in the documentation.
2777
531
2778
532
GENERATE_TESTLIST      = YES
2779
533
2780
534
# The GENERATE_BUGLIST tag can be used to enable (YES) or
2781
535
# disable (NO) the bug list. This list is created by putting \bug
2782
536
# commands in the documentation.
2783
537
2784
538
GENERATE_BUGLIST       = YES
2785
539
2786
540
# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
2787
541
# disable (NO) the deprecated list. This list is created by putting
2788
542
# \deprecated commands in the documentation.
2789
543
2790
544
GENERATE_DEPRECATEDLIST= YES
2791
545
2792
546
# The ENABLED_SECTIONS tag can be used to enable conditional
2793
547
# documentation sections, marked by \if section-label ... \endif
2794
548
# and \cond section-label ... \endcond blocks.
2795
549
2796
550
ENABLED_SECTIONS       =
2797
551
2798
552
# The MAX_INITIALIZER_LINES tag determines the maximum number of lines
2799
553
# the initial value of a variable or macro consists of for it to appear in
2800
554
# the documentation. If the initializer consists of more lines than specified
2801
555
# here it will be hidden. Use a value of 0 to hide initializers completely.
2802
556
# The appearance of the initializer of individual variables and macros in the
2803
557
# documentation can be controlled using \showinitializer or \hideinitializer
2804
558
# command in the documentation regardless of this setting.
2805
559
2806
560
MAX_INITIALIZER_LINES  = 30
2807
561
2808
562
# Set the SHOW_USED_FILES tag to NO to disable the list of files generated
2809
563
# at the bottom of the documentation of classes and structs. If set to YES the
2810
564
# list will mention the files that were used to generate the documentation.
2811
565
2812
566
SHOW_USED_FILES        = YES
2813
567
2814
568
# Set the SHOW_FILES tag to NO to disable the generation of the Files page.
2815
569
# This will remove the Files entry from the Quick Index and from the
2816
570
# Folder Tree View (if specified). The default is YES.
2817
571
2818
572
SHOW_FILES             = YES
2819
573
2820
574
# Set the SHOW_NAMESPACES tag to NO to disable the generation of the
2821
575
# Namespaces page.
2822
576
# This will remove the Namespaces entry from the Quick Index
2823
577
# and from the Folder Tree View (if specified). The default is YES.
2824
578
2825
579
SHOW_NAMESPACES        = YES
2826
580
2827
581
# The FILE_VERSION_FILTER tag can be used to specify a program or script that
2828
582
# doxygen should invoke to get the current version for each file (typically from
2829
583
# the version control system). Doxygen will invoke the program by executing (via
2830
584
# popen()) the command <command> <input-file>, where <command> is the value of
2831
585
# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file
2832
586
# provided by doxygen. Whatever the program writes to standard output
2833
587
# is used as the file version. See the manual for examples.
2834
588
2835
589
FILE_VERSION_FILTER    =
2836
590
2837
591
# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
2838
592
# by doxygen. The layout file controls the global structure of the generated
2839
593
# output files in an output format independent way. To create the layout file
2840
594
# that represents doxygen's defaults, run doxygen with the -l option.
2841
595
# You can optionally specify a file name after the option, if omitted
2842
596
# DoxygenLayout.xml will be used as the name of the layout file.
2843
597
2844
598
LAYOUT_FILE            =
2845
599
2846
600
# The CITE_BIB_FILES tag can be used to specify one or more bib files
2847
601
# containing the references data. This must be a list of .bib files. The
2848
602
# .bib extension is automatically appended if omitted. Using this command
2849
603
# requires the bibtex tool to be installed. See also
2850
604
# http://en.wikipedia.org/wiki/BibTeX for more info. For LaTeX the style
2851
605
# of the bibliography can be controlled using LATEX_BIB_STYLE. To use this
2852
606
# feature you need bibtex and perl available in the search path. Do not use
2853
607
# file names with spaces, bibtex cannot handle them.
2854
608
2855
609
CITE_BIB_FILES         =
2856
610
2857
611
#---------------------------------------------------------------------------
2858
612
# configuration options related to warning and progress messages
2859
613
#---------------------------------------------------------------------------
2860
614
2861
615
# The QUIET tag can be used to turn on/off the messages that are generated
2862
616
# by doxygen. Possible values are YES and NO. If left blank NO is used.
2863
617
2864
618
QUIET                  = NO
2865
619
2866
620
# The WARNINGS tag can be used to turn on/off the warning messages that are
2867
621
# generated by doxygen. Possible values are YES and NO. If left blank
2868
622
# NO is used.
2869
623
2870
624
WARNINGS               = YES
2871
625
2872
626
# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
2873
627
# for undocumented members. If EXTRACT_ALL is set to YES then this flag will
2874
628
# automatically be disabled.
2875
629
2876
630
WARN_IF_UNDOCUMENTED   = YES
2877
631
2878
632
# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
2879
633
# potential errors in the documentation, such as not documenting some
2880
634
# parameters in a documented function, or documenting parameters that
2881
635
# don't exist or using markup commands wrongly.
2882
636
2883
637
WARN_IF_DOC_ERROR      = YES
2884
638
2885
639
# The WARN_NO_PARAMDOC option can be enabled to get warnings for
2886
640
# functions that are documented, but have no documentation for their parameters
2887
641
# or return value. If set to NO (the default) doxygen will only warn about
2888
642
# wrong or incomplete parameter documentation, but not about the absence of
2889
643
# documentation.
2890
644
2891
645
WARN_NO_PARAMDOC       = YES
2892
646
2893
647
# The WARN_FORMAT tag determines the format of the warning messages that
2894
648
# doxygen can produce. The string should contain the $file, $line, and $text
2895
649
# tags, which will be replaced by the file and line number from which the
2896
650
# warning originated and the warning text. Optionally the format may contain
2897
651
# $version, which will be replaced by the version of the file (if it could
2898
652
# be obtained via FILE_VERSION_FILTER)
2899
653
2900
654
WARN_FORMAT            = "$file:$line: $text"
2901
655
2902
656
# The WARN_LOGFILE tag can be used to specify a file to which warning
2903
657
# and error messages should be written. If left blank the output is written
2904
658
# to stderr.
2905
659
2906
660
WARN_LOGFILE           =
2907
661
2908
662
#---------------------------------------------------------------------------
2909
663
# configuration options related to the input files
2910
664
#---------------------------------------------------------------------------
2911
665
2912
666
# The INPUT tag can be used to specify the files and/or directories that contain
2913
667
# documented source files. You may enter file names like "myfile.cpp" or
2914
668
# directories like "/usr/src/myproject". Separate the files or directories
2915
669
# with spaces.
2916
670
2917
671
INPUT                  = ${SOURCE_DIRS}
2918
672
2919
673
# This tag can be used to specify the character encoding of the source files
2920
674
# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
2921
675
# also the default input encoding. Doxygen uses libiconv (or the iconv built
2922
676
# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for
2923
677
# the list of possible encodings.
2924
678
2925
679
INPUT_ENCODING         = UTF-8
2926
680
2927
681
# If the value of the INPUT tag contains directories, you can use the
2928
682
# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
2929
683
# and *.h) to filter out the source-files in the directories. If left
2930
684
# blank the following patterns are tested:
2931
685
# *.c *.cc *.cxx *.cpp *.c++ *.d *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh
2932
686
# *.hxx *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.dox *.py
2933
687
# *.f90 *.f *.for *.vhd *.vhdl
2934
688
2935
689
FILE_PATTERNS          =
2936
690
2937
691
# The RECURSIVE tag can be used to turn specify whether or not subdirectories
2938
692
# should be searched for input files as well. Possible values are YES and NO.
2939
693
# If left blank NO is used.
2940
694
2941
695
RECURSIVE              = YES
2942
696
2943
697
# The EXCLUDE tag can be used to specify files and/or directories that should be
2944
698
# excluded from the INPUT source files. This way you can easily exclude a
2945
699
# subdirectory from a directory tree whose root is specified with the INPUT tag.
2946
700
# Note that relative paths are relative to the directory from which doxygen is
2947
701
# run.
2948
702
2949
703
EXCLUDE                =
2950
704
2951
705
# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
2952
706
# directories that are symbolic links (a Unix file system feature) are excluded
2953
707
# from the input.
2954
708
2955
709
EXCLUDE_SYMLINKS       = NO
2956
710
2957
711
# If the value of the INPUT tag contains directories, you can use the
2958
712
# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
2959
713
# certain files from those directories. Note that the wildcards are matched
2960
714
# against the file with absolute path, so to exclude all test directories
2961
715
# for example use the pattern */test/*
2962
716
2963
717
EXCLUDE_PATTERNS       =
2964
718
2965
719
# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
2966
720
# (namespaces, classes, functions, etc.) that should be excluded from the
2967
721
# output. The symbol name can be a fully qualified name, a word, or if the
2968
722
# wildcard * is used, a substring. Examples: ANamespace, AClass,
2969
723
# AClass::ANamespace, ANamespace::*Test
2970
724
2971
725
EXCLUDE_SYMBOLS        =
2972
726
2973
727
# The EXAMPLE_PATH tag can be used to specify one or more files or
2974
728
# directories that contain example code fragments that are included (see
2975
729
# the \include command).
2976
730
2977
731
EXAMPLE_PATH           = @CMAKE_SOURCE_DIR@/examples
2978
732
2979
733
# If the value of the EXAMPLE_PATH tag contains directories, you can use the
2980
734
# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
2981
735
# and *.h) to filter out the source-files in the directories. If left
2982
736
# blank all files are included.
2983
737
2984
738
EXAMPLE_PATTERNS       =
2985
739
2986
740
# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
2987
741
# searched for input files to be used with the \include or \dontinclude
2988
742
# commands irrespective of the value of the RECURSIVE tag.
2989
743
# Possible values are YES and NO. If left blank NO is used.
2990
744
2991
745
EXAMPLE_RECURSIVE      = YES
2992
746
2993
747
# The IMAGE_PATH tag can be used to specify one or more files or
2994
748
# directories that contain image that are included in the documentation (see
2995
749
# the \image command).
2996
750
2997
751
IMAGE_PATH             =
2998
752
2999
753
# The INPUT_FILTER tag can be used to specify a program that doxygen should
3000
754
# invoke to filter for each input file. Doxygen will invoke the filter program
3001
755
# by executing (via popen()) the command <filter> <input-file>, where <filter>
3002
756
# is the value of the INPUT_FILTER tag, and <input-file> is the name of an
3003
757
# input file. Doxygen will then use the output that the filter program writes
3004
758
# to standard output.
3005
759
# If FILTER_PATTERNS is specified, this tag will be
3006
760
# ignored.
3007
761
3008
762
INPUT_FILTER           =
3009
763
3010
764
# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
3011
765
# basis.
3012
766
# Doxygen will compare the file name with each pattern and apply the
3013
767
# filter if there is a match.
3014
768
# The filters are a list of the form:
3015
769
# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
3016
770
# info on how filters are used. If FILTER_PATTERNS is empty or if
3017
771
# non of the patterns match the file name, INPUT_FILTER is applied.
3018
772
3019
773
FILTER_PATTERNS        =
3020
774
3021
775
# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
3022
776
# INPUT_FILTER) will be used to filter the input files when producing source
3023
777
# files to browse (i.e. when SOURCE_BROWSER is set to YES).
3024
778
3025
779
FILTER_SOURCE_FILES    = NO
3026
780
3027
781
# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
3028
782
# pattern. A pattern will override the setting for FILTER_PATTERN (if any)
3029
783
# and it is also possible to disable source filtering for a specific pattern
3030
784
# using *.ext= (so without naming a filter). This option only has effect when
3031
785
# FILTER_SOURCE_FILES is enabled.
3032
786
3033
787
FILTER_SOURCE_PATTERNS =
3034
788
3035
789
# If the USE_MD_FILE_AS_MAINPAGE tag refers to the name of a markdown file that
3036
790
# is part of the input, its contents will be placed on the main page (index.html).
3037
791
# This can be useful if you have a project on for instance GitHub and want reuse
3038
792
# the introduction page also for the doxygen output.
3039
793
3040
794
USE_MDFILE_AS_MAINPAGE =
3041
795
3042
796
#---------------------------------------------------------------------------
3043
797
# configuration options related to source browsing
3044
798
#---------------------------------------------------------------------------
3045
799
3046
800
# If the SOURCE_BROWSER tag is set to YES then a list of source files will
3047
801
# be generated. Documented entities will be cross-referenced with these sources.
3048
802
# Note: To get rid of all source code in the generated output, make sure also
3049
803
# VERBATIM_HEADERS is set to NO.
3050
804
3051
805
SOURCE_BROWSER         = YES
3052
806
3053
807
# Setting the INLINE_SOURCES tag to YES will include the body
3054
808
# of functions and classes directly in the documentation.
3055
809
3056
810
INLINE_SOURCES         = NO
3057
811
3058
812
# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
3059
813
# doxygen to hide any special comment blocks from generated source code
3060
814
# fragments. Normal C, C++ and Fortran comments will always remain visible.
3061
815
3062
816
STRIP_CODE_COMMENTS    = YES
3063
817
3064
818
# If the REFERENCED_BY_RELATION tag is set to YES
3065
819
# then for each documented function all documented
3066
820
# functions referencing it will be listed.
3067
821
3068
822
REFERENCED_BY_RELATION = YES
3069
823
3070
824
# If the REFERENCES_RELATION tag is set to YES
3071
825
# then for each documented function all documented entities
3072
826
# called/used by that function will be listed.
3073
827
3074
828
REFERENCES_RELATION    = YES
3075
829
3076
830
# If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
3077
831
# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
3078
832
# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
3079
833
# link to the source code.
3080
834
# Otherwise they will link to the documentation.
3081
835
3082
836
REFERENCES_LINK_SOURCE = YES
3083
837
3084
838
# If the USE_HTAGS tag is set to YES then the references to source code
3085
839
# will point to the HTML generated by the htags(1) tool instead of doxygen
3086
840
# built-in source browser. The htags tool is part of GNU's global source
3087
841
# tagging system (see http://www.gnu.org/software/global/global.html). You
3088
842
# will need version 4.8.6 or higher.
3089
843
3090
844
USE_HTAGS              = NO
3091
845
3092
846
# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
3093
847
# will generate a verbatim copy of the header file for each class for
3094
848
# which an include is specified. Set to NO to disable this.
3095
849
3096
850
VERBATIM_HEADERS       = YES
3097
851
3098
852
#---------------------------------------------------------------------------
3099
853
# configuration options related to the alphabetical class index
3100
854
#---------------------------------------------------------------------------
3101
855
3102
856
# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
3103
857
# of all compounds will be generated. Enable this if the project
3104
858
# contains a lot of classes, structs, unions or interfaces.
3105
859
3106
860
ALPHABETICAL_INDEX     = YES
3107
861
3108
862
# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
3109
863
# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
3110
864
# in which this list will be split (can be a number in the range [1..20])
3111
865
3112
866
COLS_IN_ALPHA_INDEX    = 5
3113
867
3114
868
# In case all classes in a project start with a common prefix, all
3115
869
# classes will be put under the same header in the alphabetical index.
3116
870
# The IGNORE_PREFIX tag can be used to specify one or more prefixes that
3117
871
# should be ignored while generating the index headers.
3118
872
3119
873
IGNORE_PREFIX          =
3120
874
3121
875
#---------------------------------------------------------------------------
3122
876
# configuration options related to the HTML output
3123
877
#---------------------------------------------------------------------------
3124
878
3125
879
# If the GENERATE_HTML tag is set to YES (the default) Doxygen will
3126
880
# generate HTML output.
3127
881
3128
882
GENERATE_HTML          = YES
3129
883
3130
884
# The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
3131
885
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
3132
886
# put in front of it. If left blank `html' will be used as the default path.
3133
887
3134
888
HTML_OUTPUT            = html
3135
889
3136
890
# The HTML_FILE_EXTENSION tag can be used to specify the file extension for
3137
891
# each generated HTML page (for example: .htm,.php,.asp). If it is left blank
3138
892
# doxygen will generate files with .html extension.
3139
893
3140
894
HTML_FILE_EXTENSION    = .html
3141
895
3142
896
# The HTML_HEADER tag can be used to specify a personal HTML header for
3143
897
# each generated HTML page. If it is left blank doxygen will generate a
3144
898
# standard header. Note that when using a custom header you are responsible
3145
899
#  for the proper inclusion of any scripts and style sheets that doxygen
3146
900
# needs, which is dependent on the configuration options used.
3147
901
# It is advised to generate a default header using "doxygen -w html
3148
902
# header.html footer.html stylesheet.css YourConfigFile" and then modify
3149
903
# that header. Note that the header is subject to change so you typically
3150
904
# have to redo this when upgrading to a newer version of doxygen or when
3151
905
# changing the value of configuration settings such as GENERATE_TREEVIEW!
3152
906
3153
907
HTML_HEADER            =
3154
908
3155
909
# The HTML_FOOTER tag can be used to specify a personal HTML footer for
3156
910
# each generated HTML page. If it is left blank doxygen will generate a
3157
911
# standard footer.
3158
912
3159
913
HTML_FOOTER            =
3160
914
3161
915
# The HTML_STYLESHEET tag can be used to specify a user-defined cascading
3162
916
# style sheet that is used by each HTML page. It can be used to
3163
917
# fine-tune the look of the HTML output. If left blank doxygen will
3164
918
# generate a default style sheet. Note that it is recommended to use
3165
919
# HTML_EXTRA_STYLESHEET instead of this one, as it is more robust and this
3166
920
# tag will in the future become obsolete.
3167
921
3168
922
HTML_STYLESHEET        =
3169
923
3170
924
# The HTML_EXTRA_STYLESHEET tag can be used to specify an additional
3171
925
# user-defined cascading style sheet that is included after the standard
3172
926
# style sheets created by doxygen. Using this option one can overrule
3173
927
# certain style aspects. This is preferred over using HTML_STYLESHEET
3174
928
# since it does not replace the standard style sheet and is therefor more
3175
929
# robust against future updates. Doxygen will copy the style sheet file to
3176
930
# the output directory.
3177
931
3178
932
HTML_EXTRA_STYLESHEET  = @CMAKE_CURRENT_SOURCE_DIR@/extra.css
3179
933
3180
934
# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
3181
935
# other source files which should be copied to the HTML output directory. Note
3182
936
# that these files will be copied to the base HTML output directory. Use the
3183
937
# $relpath$ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
3184
938
# files. In the HTML_STYLESHEET file, use the file name only. Also note that
3185
939
# the files will be copied as-is; there are no commands or markers available.
3186
940
3187
941
HTML_EXTRA_FILES       =
3188
942
3189
943
# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output.
3190
944
# Doxygen will adjust the colors in the style sheet and background images
3191
945
# according to this color. Hue is specified as an angle on a colorwheel,
3192
946
# see http://en.wikipedia.org/wiki/Hue for more information.
3193
947
# For instance the value 0 represents red, 60 is yellow, 120 is green,
3194
948
# 180 is cyan, 240 is blue, 300 purple, and 360 is red again.
3195
949
# The allowed range is 0 to 359.
3196
950
3197
951
HTML_COLORSTYLE_HUE    = 220
3198
952
3199
953
# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of
3200
954
# the colors in the HTML output. For a value of 0 the output will use
3201
955
# grayscales only. A value of 255 will produce the most vivid colors.
3202
956
3203
957
HTML_COLORSTYLE_SAT    = 100
3204
958
3205
959
# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to
3206
960
# the luminance component of the colors in the HTML output. Values below
3207
961
# 100 gradually make the output lighter, whereas values above 100 make
3208
962
# the output darker. The value divided by 100 is the actual gamma applied,
3209
963
# so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2,
3210
964
# and 100 does not change the gamma.
3211
965
3212
966
HTML_COLORSTYLE_GAMMA  = 80
3213
967
3214
968
# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
3215
969
# page will contain the date and time when the page was generated. Setting
3216
970
# this to NO can help when comparing the output of multiple runs.
3217
971
3218
972
HTML_TIMESTAMP         = YES
3219
973
3220
974
# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
3221
975
# documentation will contain sections that can be hidden and shown after the
3222
976
# page has loaded.
3223
977
3224
978
HTML_DYNAMIC_SECTIONS  = YES
3225
979
3226
980
# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of
3227
981
# entries shown in the various tree structured indices initially; the user
3228
982
# can expand and collapse entries dynamically later on. Doxygen will expand
3229
983
# the tree to such a level that at most the specified number of entries are
3230
984
# visible (unless a fully collapsed tree already exceeds this amount).
3231
985
# So setting the number of entries 1 will produce a full collapsed tree by
3232
986
# default. 0 is a special value representing an infinite number of entries
3233
987
# and will result in a full expanded tree by default.
3234
988
3235
989
HTML_INDEX_NUM_ENTRIES = 100
3236
990
3237
991
# If the GENERATE_DOCSET tag is set to YES, additional index files
3238
992
# will be generated that can be used as input for Apple's Xcode 3
3239
993
# integrated development environment, introduced with OSX 10.5 (Leopard).
3240
994
# To create a documentation set, doxygen will generate a Makefile in the
3241
995
# HTML output directory. Running make will produce the docset in that
3242
996
# directory and running "make install" will install the docset in
3243
997
# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find
3244
998
# it at startup.
3245
999
# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
3246
1000
# for more information.
3247
1001
3248
1002
GENERATE_DOCSET        = NO
3249
1003
3250
1004
# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the
3251
1005
# feed. A documentation feed provides an umbrella under which multiple
3252
1006
# documentation sets from a single provider (such as a company or product suite)
3253
1007
# can be grouped.
3254
1008
3255
1009
DOCSET_FEEDNAME        = "Doxygen generated docs"
3256
1010
3257
1011
# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that
3258
1012
# should uniquely identify the documentation set bundle. This should be a
3259
1013
# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen
3260
1014
# will append .docset to the name.
3261
1015
3262
1016
DOCSET_BUNDLE_ID       = org.doxygen.Project
3263
1017
3264
1018
# When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely
3265
1019
# identify the documentation publisher. This should be a reverse domain-name
3266
1020
# style string, e.g. com.mycompany.MyDocSet.documentation.
3267
1021
3268
1022
DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
3269
1023
3270
1024
# The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher.
3271
1025
3272
1026
DOCSET_PUBLISHER_NAME  = Publisher
3273
1027
3274
1028
# If the GENERATE_HTMLHELP tag is set to YES, additional index files
3275
1029
# will be generated that can be used as input for tools like the
3276
1030
# Microsoft HTML help workshop to generate a compiled HTML help file (.chm)
3277
1031
# of the generated HTML documentation.
3278
1032
3279
1033
GENERATE_HTMLHELP      = NO
3280
1034
3281
1035
# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
3282
1036
# be used to specify the file name of the resulting .chm file. You
3283
1037
# can add a path in front of the file if the result should not be
3284
1038
# written to the html output directory.
3285
1039
3286
1040
CHM_FILE               =
3287
1041
3288
1042
# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
3289
1043
# be used to specify the location (absolute path including file name) of
3290
1044
# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
3291
1045
# the HTML help compiler on the generated index.hhp.
3292
1046
3293
1047
HHC_LOCATION           =
3294
1048
3295
1049
# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
3296
1050
# controls if a separate .chi index file is generated (YES) or that
3297
1051
# it should be included in the master .chm file (NO).
3298
1052
3299
1053
GENERATE_CHI           = NO
3300
1054
3301
1055
# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING
3302
1056
# is used to encode HtmlHelp index (hhk), content (hhc) and project file
3303
1057
# content.
3304
1058
3305
1059
CHM_INDEX_ENCODING     =
3306
1060
3307
1061
# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
3308
1062
# controls whether a binary table of contents is generated (YES) or a
3309
1063
# normal table of contents (NO) in the .chm file.
3310
1064
3311
1065
BINARY_TOC             = NO
3312
1066
3313
1067
# The TOC_EXPAND flag can be set to YES to add extra items for group members
3314
1068
# to the contents of the HTML help documentation and to the tree view.
3315
1069
3316
1070
TOC_EXPAND             = NO
3317
1071
3318
1072
# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
3319
1073
# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated
3320
1074
# that can be used as input for Qt's qhelpgenerator to generate a
3321
1075
# Qt Compressed Help (.qch) of the generated HTML documentation.
3322
1076
3323
1077
GENERATE_QHP           = NO
3324
1078
3325
1079
# If the QHG_LOCATION tag is specified, the QCH_FILE tag can
3326
1080
# be used to specify the file name of the resulting .qch file.
3327
1081
# The path specified is relative to the HTML output folder.
3328
1082
3329
1083
QCH_FILE               =
3330
1084
3331
1085
# The QHP_NAMESPACE tag specifies the namespace to use when generating
3332
1086
# Qt Help Project output. For more information please see
3333
1087
# http://doc.trolltech.com/qthelpproject.html#namespace
3334
1088
3335
1089
QHP_NAMESPACE          = org.doxygen.Project
3336
1090
3337
1091
# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating
3338
1092
# Qt Help Project output. For more information please see
3339
1093
# http://doc.trolltech.com/qthelpproject.html#virtual-folders
3340
1094
3341
1095
QHP_VIRTUAL_FOLDER     = doc
3342
1096
3343
1097
# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to
3344
1098
# add. For more information please see
3345
1099
# http://doc.trolltech.com/qthelpproject.html#custom-filters
3346
1100
3347
1101
QHP_CUST_FILTER_NAME   =
3348
1102
3349
1103
# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the
3350
1104
# custom filter to add. For more information please see
3351
1105
# <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters">
3352
1106
# Qt Help Project / Custom Filters</a>.
3353
1107
3354
1108
QHP_CUST_FILTER_ATTRS  =
3355
1109
3356
1110
# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
3357
1111
# project's
3358
1112
# filter section matches.
3359
1113
# <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes">
3360
1114
# Qt Help Project / Filter Attributes</a>.
3361
1115
3362
1116
QHP_SECT_FILTER_ATTRS  =
3363
1117
3364
1118
# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can
3365
1119
# be used to specify the location of Qt's qhelpgenerator.
3366
1120
# If non-empty doxygen will try to run qhelpgenerator on the generated
3367
1121
# .qhp file.
3368
1122
3369
1123
QHG_LOCATION           =
3370
1124
3371
1125
# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files
3372
1126
#  will be generated, which together with the HTML files, form an Eclipse help
3373
1127
# plugin. To install this plugin and make it available under the help contents
3374
1128
# menu in Eclipse, the contents of the directory containing the HTML and XML
3375
1129
# files needs to be copied into the plugins directory of eclipse. The name of
3376
1130
# the directory within the plugins directory should be the same as
3377
1131
# the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before
3378
1132
# the help appears.
3379
1133
3380
1134
GENERATE_ECLIPSEHELP   = NO
3381
1135
3382
1136
# A unique identifier for the eclipse help plugin. When installing the plugin
3383
1137
# the directory name containing the HTML and XML files should also have
3384
1138
# this name.
3385
1139
3386
1140
ECLIPSE_DOC_ID         = org.doxygen.Project
3387
1141
3388
1142
# The DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs)
3389
1143
# at top of each HTML page. The value NO (the default) enables the index and
3390
1144
# the value YES disables it. Since the tabs have the same information as the
3391
1145
# navigation tree you can set this option to NO if you already set
3392
1146
# GENERATE_TREEVIEW to YES.
3393
1147
3394
1148
DISABLE_INDEX          = YES
3395
1149
3396
1150
# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
3397
1151
# structure should be generated to display hierarchical information.
3398
1152
# If the tag value is set to YES, a side panel will be generated
3399
1153
# containing a tree-like index structure (just like the one that
3400
1154
# is generated for HTML Help). For this to work a browser that supports
3401
1155
# JavaScript, DHTML, CSS and frames is required (i.e. any modern browser).
3402
1156
# Windows users are probably better off using the HTML help feature.
3403
1157
# Since the tree basically has the same information as the tab index you
3404
1158
# could consider to set DISABLE_INDEX to NO when enabling this option.
3405
1159
3406
1160
GENERATE_TREEVIEW      = YES
3407
1161
3408
1162
# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values
3409
1163
# (range [0,1..20]) that doxygen will group on one line in the generated HTML
3410
1164
# documentation. Note that a value of 0 will completely suppress the enum
3411
1165
# values from appearing in the overview section.
3412
1166
3413
1167
ENUM_VALUES_PER_LINE   = 1
3414
1168
3415
1169
# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
3416
1170
# used to set the initial width (in pixels) of the frame in which the tree
3417
1171
# is shown.
3418
1172
3419
1173
TREEVIEW_WIDTH         = 250
3420
1174
3421
1175
# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open
3422
1176
# links to external symbols imported via tag files in a separate window.
3423
1177
3424
1178
EXT_LINKS_IN_WINDOW    = NO
3425
1179
3426
1180
# Use this tag to change the font size of Latex formulas included
3427
1181
# as images in the HTML documentation. The default is 10. Note that
3428
1182
# when you change the font size after a successful doxygen run you need
3429
1183
# to manually remove any form_*.png images from the HTML output directory
3430
1184
# to force them to be regenerated.
3431
1185
3432
1186
FORMULA_FONTSIZE       = 10
3433
1187
3434
1188
# Use the FORMULA_TRANPARENT tag to determine whether or not the images
3435
1189
# generated for formulas are transparent PNGs. Transparent PNGs are
3436
1190
# not supported properly for IE 6.0, but are supported on all modern browsers.
3437
1191
# Note that when changing this option you need to delete any form_*.png files
3438
1192
# in the HTML output before the changes have effect.
3439
1193
3440
1194
FORMULA_TRANSPARENT    = YES
3441
1195
3442
1196
# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax
3443
1197
# (see http://www.mathjax.org) which uses client side Javascript for the
3444
1198
# rendering instead of using prerendered bitmaps. Use this if you do not
3445
1199
# have LaTeX installed or if you want to formulas look prettier in the HTML
3446
1200
# output. When enabled you may also need to install MathJax separately and
3447
1201
# configure the path to it using the MATHJAX_RELPATH option.
3448
1202
3449
1203
USE_MATHJAX            = NO
3450
1204
3451
1205
# When MathJax is enabled you can set the default output format to be used for
3452
1206
# thA MathJax output. Supported types are HTML-CSS, NativeMML (i.e. MathML) and
3453
1207
# SVG. The default value is HTML-CSS, which is slower, but has the best
3454
1208
# compatibility.
3455
1209
3456
1210
MATHJAX_FORMAT         = HTML-CSS
3457
1211
3458
1212
# When MathJax is enabled you need to specify the location relative to the
3459
1213
# HTML output directory using the MATHJAX_RELPATH option. The destination
3460
1214
# directory should contain the MathJax.js script. For instance, if the mathjax
3461
1215
# directory is located at the same level as the HTML output directory, then
3462
1216
# MATHJAX_RELPATH should be ../mathjax. The default value points to
3463
1217
# the MathJax Content Delivery Network so you can quickly see the result without
3464
1218
# installing MathJax.
3465
1219
# However, it is strongly recommended to install a local
3466
1220
# copy of MathJax from http://www.mathjax.org before deployment.
3467
1221
3468
1222
MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest
3469
1223
3470
1224
# The MATHJAX_EXTENSIONS tag can be used to specify one or MathJax extension
3471
1225
# names that should be enabled during MathJax rendering.
3472
1226
3473
1227
MATHJAX_EXTENSIONS     =
3474
1228
3475
1229
# When the SEARCHENGINE tag is enabled doxygen will generate a search box
3476
1230
# for the HTML output. The underlying search engine uses javascript
3477
1231
# and DHTML and should work on any modern browser. Note that when using
3478
1232
# HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets
3479
1233
# (GENERATE_DOCSET) there is already a search function so this one should
3480
1234
# typically be disabled. For large projects the javascript based search engine
3481
1235
# can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.
3482
1236
3483
1237
SEARCHENGINE           = NO
3484
1238
3485
1239
# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
3486
1240
# implemented using a web server instead of a web client using Javascript.
3487
1241
# There are two flavours of web server based search depending on the
3488
1242
# EXTERNAL_SEARCH setting. When disabled, doxygen will generate a PHP script for
3489
1243
# searching and an index file used by the script. When EXTERNAL_SEARCH is
3490
1244
# enabled the indexing and searching needs to be provided by external tools.
3491
1245
# See the manual for details.
3492
1246
3493
1247
SERVER_BASED_SEARCH    = NO
3494
1248
3495
1249
# When EXTERNAL_SEARCH is enabled doxygen will no longer generate the PHP
3496
1250
# script for searching. Instead the search results are written to an XML file
3497
1251
# which needs to be processed by an external indexer. Doxygen will invoke an
3498
1252
# external search engine pointed to by the SEARCHENGINE_URL option to obtain
3499
1253
# the search results. Doxygen ships with an example indexer (doxyindexer) and
3500
1254
# search engine (doxysearch.cgi) which are based on the open source search engine
3501
1255
# library Xapian. See the manual for configuration details.
3502
1256
3503
1257
EXTERNAL_SEARCH        = NO
3504
1258
3505
1259
# The SEARCHENGINE_URL should point to a search engine hosted by a web server
3506
1260
# which will returned the search results when EXTERNAL_SEARCH is enabled.
3507
1261
# Doxygen ships with an example search engine (doxysearch) which is based on
3508
1262
# the open source search engine library Xapian. See the manual for configuration
3509
1263
# details.
3510
1264
3511
1265
SEARCHENGINE_URL       =
3512
1266
3513
1267
# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
3514
1268
# search data is written to a file for indexing by an external tool. With the
3515
1269
# SEARCHDATA_FILE tag the name of this file can be specified.
3516
1270
3517
1271
SEARCHDATA_FILE        = searchdata.xml
3518
1272
3519
1273
# When SERVER_BASED_SEARCH AND EXTERNAL_SEARCH are both enabled the
3520
1274
# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
3521
1275
# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
3522
1276
# projects and redirect the results back to the right project.
3523
1277
3524
1278
EXTERNAL_SEARCH_ID     =
3525
1279
3526
1280
# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
3527
1281
# projects other than the one defined by this configuration file, but that are
3528
1282
# all added to the same external search index. Each project needs to have a
3529
1283
# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id
3530
1284
# of to a relative location where the documentation can be found.
3531
1285
# The format is: EXTRA_SEARCH_MAPPINGS = id1=loc1 id2=loc2 ...
3532
1286
3533
1287
EXTRA_SEARCH_MAPPINGS  =
3534
1288
3535
1289
#---------------------------------------------------------------------------
3536
1290
# configuration options related to the LaTeX output
3537
1291
#---------------------------------------------------------------------------
3538
1292
3539
1293
# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
3540
1294
# generate Latex output.
3541
1295
3542
1296
GENERATE_LATEX         = NO
3543
1297
3544
1298
# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
3545
1299
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
3546
1300
# put in front of it. If left blank `latex' will be used as the default path.
3547
1301
3548
1302
LATEX_OUTPUT           = latex
3549
1303
3550
1304
# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
3551
1305
# invoked. If left blank `latex' will be used as the default command name.
3552
1306
# Note that when enabling USE_PDFLATEX this option is only used for
3553
1307
# generating bitmaps for formulas in the HTML output, but not in the
3554
1308
# Makefile that is written to the output directory.
3555
1309
3556
1310
LATEX_CMD_NAME         = latex
3557
1311
3558
1312
# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
3559
1313
# generate index for LaTeX. If left blank `makeindex' will be used as the
3560
1314
# default command name.
3561
1315
3562
1316
MAKEINDEX_CMD_NAME     = makeindex
3563
1317
3564
1318
# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
3565
1319
# LaTeX documents. This may be useful for small projects and may help to
3566
1320
# save some trees in general.
3567
1321
3568
1322
COMPACT_LATEX          = YES 
3569
1323
3570
1324
# The PAPER_TYPE tag can be used to set the paper type that is used
3571
1325
# by the printer. Possible values are: a4, letter, legal and
3572
1326
# executive. If left blank a4wide will be used.
3573
1327
3574
1328
PAPER_TYPE             = a4
3575
1329
3576
1330
# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
3577
1331
# packages that should be included in the LaTeX output.
3578
1332
3579
1333
EXTRA_PACKAGES         =
3580
1334
3581
1335
# The LATEX_HEADER tag can be used to specify a personal LaTeX header for
3582
1336
# the generated latex document. The header should contain everything until
3583
1337
# the first chapter. If it is left blank doxygen will generate a
3584
1338
# standard header. Notice: only use this tag if you know what you are doing!
3585
1339
3586
1340
LATEX_HEADER           =
3587
1341
3588
1342
# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for
3589
1343
# the generated latex document. The footer should contain everything after
3590
1344
# the last chapter. If it is left blank doxygen will generate a
3591
1345
# standard footer. Notice: only use this tag if you know what you are doing!
3592
1346
3593
1347
LATEX_FOOTER           =
3594
1348
3595
1349
# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
3596
1350
# is prepared for conversion to pdf (using ps2pdf). The pdf file will
3597
1351
# contain links (just like the HTML output) instead of page references
3598
1352
# This makes the output suitable for online browsing using a pdf viewer.
3599
1353
3600
1354
PDF_HYPERLINKS         = YES
3601
1355
3602
1356
# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
3603
1357
# plain latex in the generated Makefile. Set this option to YES to get a
3604
1358
# higher quality PDF documentation.
3605
1359
3606
1360
USE_PDFLATEX           = YES
3607
1361
3608
1362
# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
3609
1363
# command to the generated LaTeX files. This will instruct LaTeX to keep
3610
1364
# running if errors occur, instead of asking the user for help.
3611
1365
# This option is also used when generating formulas in HTML.
3612
1366
3613
1367
LATEX_BATCHMODE        = NO
3614
1368
3615
1369
# If LATEX_HIDE_INDICES is set to YES then doxygen will not
3616
1370
# include the index chapters (such as File Index, Compound Index, etc.)
3617
1371
# in the output.
3618
1372
3619
1373
LATEX_HIDE_INDICES     = NO
3620
1374
3621
1375
# If LATEX_SOURCE_CODE is set to YES then doxygen will include
3622
1376
# source code with syntax highlighting in the LaTeX output.
3623
1377
# Note that which sources are shown also depends on other settings
3624
1378
# such as SOURCE_BROWSER.
3625
1379
3626
1380
LATEX_SOURCE_CODE      = NO 
3627
1381
3628
1382
# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
3629
1383
# bibliography, e.g. plainnat, or ieeetr. The default style is "plain". See
3630
1384
# http://en.wikipedia.org/wiki/BibTeX for more info.
3631
1385
3632
1386
LATEX_BIB_STYLE        = plain
3633
1387
3634
1388
#---------------------------------------------------------------------------
3635
1389
# configuration options related to the RTF output
3636
1390
#---------------------------------------------------------------------------
3637
1391
3638
1392
# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
3639
1393
# The RTF output is optimized for Word 97 and may not look very pretty with
3640
1394
# other RTF readers or editors.
3641
1395
3642
1396
GENERATE_RTF           = NO
3643
1397
3644
1398
# The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
3645
1399
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
3646
1400
# put in front of it. If left blank `rtf' will be used as the default path.
3647
1401
3648
1402
RTF_OUTPUT             = rtf
3649
1403
3650
1404
# If the COMPACT_RTF tag is set to YES Doxygen generates more compact
3651
1405
# RTF documents. This may be useful for small projects and may help to
3652
1406
# save some trees in general.
3653
1407
3654
1408
COMPACT_RTF            = NO
3655
1409
3656
1410
# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
3657
1411
# will contain hyperlink fields. The RTF file will
3658
1412
# contain links (just like the HTML output) instead of page references.
3659
1413
# This makes the output suitable for online browsing using WORD or other
3660
1414
# programs which support those fields.
3661
1415
# Note: wordpad (write) and others do not support links.
3662
1416
3663
1417
RTF_HYPERLINKS         = NO
3664
1418
3665
1419
# Load style sheet definitions from file. Syntax is similar to doxygen's
3666
1420
# config file, i.e. a series of assignments. You only have to provide
3667
1421
# replacements, missing definitions are set to their default value.
3668
1422
3669
1423
RTF_STYLESHEET_FILE    =
3670
1424
3671
1425
# Set optional variables used in the generation of an rtf document.
3672
1426
# Syntax is similar to doxygen's config file.
3673
1427
3674
1428
RTF_EXTENSIONS_FILE    =
3675
1429
3676
1430
#---------------------------------------------------------------------------
3677
1431
# configuration options related to the man page output
3678
1432
#---------------------------------------------------------------------------
3679
1433
3680
1434
# If the GENERATE_MAN tag is set to YES (the default) Doxygen will
3681
1435
# generate man pages
3682
1436
3683
1437
GENERATE_MAN           = NO
3684
1438
3685
1439
# The MAN_OUTPUT tag is used to specify where the man pages will be put.
3686
1440
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
3687
1441
# put in front of it. If left blank `man' will be used as the default path.
3688
1442
3689
1443
MAN_OUTPUT             = man
3690
1444
3691
1445
# The MAN_EXTENSION tag determines the extension that is added to
3692
1446
# the generated man pages (default is the subroutine's section .3)
3693
1447
3694
1448
MAN_EXTENSION          = .3
3695
1449
3696
1450
# If the MAN_LINKS tag is set to YES and Doxygen generates man output,
3697
1451
# then it will generate one additional man file for each entity
3698
1452
# documented in the real man page(s). These additional files
3699
1453
# only source the real man page, but without them the man command
3700
1454
# would be unable to find the correct page. The default is NO.
3701
1455
3702
1456
MAN_LINKS              = NO
3703
1457
3704
1458
#---------------------------------------------------------------------------
3705
1459
# configuration options related to the XML output
3706
1460
#---------------------------------------------------------------------------
3707
1461
3708
1462
# If the GENERATE_XML tag is set to YES Doxygen will
3709
1463
# generate an XML file that captures the structure of
3710
1464
# the code including all documentation.
3711
1465
3712
1466
GENERATE_XML           = YES
3713
1467
3714
1468
# The XML_OUTPUT tag is used to specify where the XML pages will be put.
3715
1469
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
3716
1470
# put in front of it. If left blank `xml' will be used as the default path.
3717
1471
3718
1472
XML_OUTPUT             = xml
3719
1473
3720
1474
# The XML_SCHEMA tag can be used to specify an XML schema,
3721
1475
# which can be used by a validating XML parser to check the
3722
1476
# syntax of the XML files.
3723
1477
3724
1478
XML_SCHEMA             =
3725
1479
3726
1480
# The XML_DTD tag can be used to specify an XML DTD,
3727
1481
# which can be used by a validating XML parser to check the
3728
1482
# syntax of the XML files.
3729
1483
3730
1484
XML_DTD                =
3731
1485
3732
1486
# If the XML_PROGRAMLISTING tag is set to YES Doxygen will
3733
1487
# dump the program listings (including syntax highlighting
3734
1488
# and cross-referencing information) to the XML output. Note that
3735
1489
# enabling this will significantly increase the size of the XML output.
3736
1490
3737
1491
XML_PROGRAMLISTING     = YES
3738
1492
3739
1493
#---------------------------------------------------------------------------
3740
1494
# configuration options for the AutoGen Definitions output
3741
1495
#---------------------------------------------------------------------------
3742
1496
3743
1497
# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
3744
1498
# generate an AutoGen Definitions (see autogen.sf.net) file
3745
1499
# that captures the structure of the code including all
3746
1500
# documentation. Note that this feature is still experimental
3747
1501
# and incomplete at the moment.
3748
1502
3749
1503
GENERATE_AUTOGEN_DEF   = NO
3750
1504
3751
1505
#---------------------------------------------------------------------------
3752
1506
# configuration options related to the Perl module output
3753
1507
#---------------------------------------------------------------------------
3754
1508
3755
1509
# If the GENERATE_PERLMOD tag is set to YES Doxygen will
3756
1510
# generate a Perl module file that captures the structure of
3757
1511
# the code including all documentation. Note that this
3758
1512
# feature is still experimental and incomplete at the
3759
1513
# moment.
3760
1514
3761
1515
GENERATE_PERLMOD       = NO
3762
1516
3763
1517
# If the PERLMOD_LATEX tag is set to YES Doxygen will generate
3764
1518
# the necessary Makefile rules, Perl scripts and LaTeX code to be able
3765
1519
# to generate PDF and DVI output from the Perl module output.
3766
1520
3767
1521
PERLMOD_LATEX          = NO
3768
1522
3769
1523
# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
3770
1524
# nicely formatted so it can be parsed by a human reader.
3771
1525
# This is useful
3772
1526
# if you want to understand what is going on.
3773
1527
# On the other hand, if this
3774
1528
# tag is set to NO the size of the Perl module output will be much smaller
3775
1529
# and Perl will parse it just the same.
3776
1530
3777
1531
PERLMOD_PRETTY         = YES
3778
1532
3779
1533
# The names of the make variables in the generated doxyrules.make file
3780
1534
# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
3781
1535
# This is useful so different doxyrules.make files included by the same
3782
1536
# Makefile don't overwrite each other's variables.
3783
1537
3784
1538
PERLMOD_MAKEVAR_PREFIX =
3785
1539
3786
1540
#---------------------------------------------------------------------------
3787
1541
# Configuration options related to the preprocessor
3788
1542
#---------------------------------------------------------------------------
3789
1543
3790
1544
# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
3791
1545
# evaluate all C-preprocessor directives found in the sources and include
3792
1546
# files.
3793
1547
3794
1548
ENABLE_PREPROCESSING   = YES
3795
1549
3796
1550
# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
3797
1551
# names in the source code. If set to NO (the default) only conditional
3798
1552
# compilation will be performed. Macro expansion can be done in a controlled
3799
1553
# way by setting EXPAND_ONLY_PREDEF to YES.
3800
1554
3801
1555
MACRO_EXPANSION        = NO
3802
1556
3803
1557
# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
3804
1558
# then the macro expansion is limited to the macros specified with the
3805
1559
# PREDEFINED and EXPAND_AS_DEFINED tags.
3806
1560
3807
1561
EXPAND_ONLY_PREDEF     = NO
3808
1562
3809
1563
# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
3810
1564
# pointed to by INCLUDE_PATH will be searched when a #include is found.
3811
1565
3812
1566
SEARCH_INCLUDES        = YES
3813
1567
3814
1568
# The INCLUDE_PATH tag can be used to specify one or more directories that
3815
1569
# contain include files that are not input files but should be processed by
3816
1570
# the preprocessor.
3817
1571
3818
1572
INCLUDE_PATH           =
3819
1573
3820
1574
# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
3821
1575
# patterns (like *.h and *.hpp) to filter out the header-files in the
3822
1576
# directories. If left blank, the patterns specified with FILE_PATTERNS will
3823
1577
# be used.
3824
1578
3825
1579
INCLUDE_FILE_PATTERNS  =
3826
1580
3827
1581
# The PREDEFINED tag can be used to specify one or more macro names that
3828
1582
# are defined before the preprocessor is started (similar to the -D option of
3829
1583
# gcc). The argument of the tag is a list of macros of the form: name
3830
1584
# or name=definition (no spaces). If the definition and the = are
3831
1585
# omitted =1 is assumed. To prevent a macro definition from being
3832
1586
# undefined via #undef or recursively expanded use the := operator
3833
1587
# instead of the = operator.
3834
1588
3835
1589
PREDEFINED             =
3836
1590
3837
1591
# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
3838
1592
# this tag can be used to specify a list of macro names that should be expanded.
3839
1593
# The macro definition that is found in the sources will be used.
3840
1594
# Use the PREDEFINED tag if you want to use a different macro definition that
3841
1595
# overrules the definition found in the source code.
3842
1596
3843
1597
EXPAND_AS_DEFINED      =
3844
1598
3845
1599
# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
3846
1600
# doxygen's preprocessor will remove all references to function-like macros
3847
1601
# that are alone on a line, have an all uppercase name, and do not end with a
3848
1602
# semicolon, because these will confuse the parser if not removed.
3849
1603
3850
1604
SKIP_FUNCTION_MACROS   = YES
3851
1605
3852
1606
#---------------------------------------------------------------------------
3853
1607
# Configuration::additions related to external references
3854
1608
#---------------------------------------------------------------------------
3855
1609
3856
1610
# The TAGFILES option can be used to specify one or more tagfiles. For each
3857
1611
# tag file the location of the external documentation should be added. The
3858
1612
# format of a tag file without this location is as follows:
3859
1613
#
3860
1614
# TAGFILES = file1 file2 ...
3861
1615
# Adding location for the tag files is done as follows:
3862
1616
#
3863
1617
# TAGFILES = file1=loc1 "file2 = loc2" ...
3864
1618
# where "loc1" and "loc2" can be relative or absolute paths
3865
1619
# or URLs. Note that each tag file must have a unique name (where the name does
3866
1620
# NOT include the path). If a tag file is not located in the directory in which
3867
1621
# doxygen is run, you must also specify the path to the tagfile here.
3868
1622
3869
1623
TAGFILES               =
3870
1624
3871
1625
# When a file name is specified after GENERATE_TAGFILE, doxygen will create
3872
1626
# a tag file that is based on the input files it reads.
3873
1627
3874
1628
GENERATE_TAGFILE       =
3875
1629
3876
1630
# If the ALLEXTERNALS tag is set to YES all external classes will be listed
3877
1631
# in the class index. If set to NO only the inherited external classes
3878
1632
# will be listed.
3879
1633
3880
1634
ALLEXTERNALS           = NO
3881
1635
3882
1636
# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
3883
1637
# in the modules index. If set to NO, only the current project's groups will
3884
1638
# be listed.
3885
1639
3886
1640
EXTERNAL_GROUPS        = YES
3887
1641
3888
1642
# The PERL_PATH should be the absolute path and name of the perl script
3889
1643
# interpreter (i.e. the result of `which perl').
3890
1644
3891
1645
PERL_PATH              = /usr/bin/perl
3892
1646
3893
1647
#---------------------------------------------------------------------------
3894
1648
# Configuration options related to the dot tool
3895
1649
#---------------------------------------------------------------------------
3896
1650
3897
1651
# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
3898
1652
# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
3899
1653
# or super classes. Setting the tag to NO turns the diagrams off. Note that
3900
1654
# this option also works with HAVE_DOT disabled, but it is recommended to
3901
1655
# install and use dot, since it yields more powerful graphs.
3902
1656
3903
1657
CLASS_DIAGRAMS         = YES
3904
1658
3905
1659
# You can define message sequence charts within doxygen comments using the \msc
3906
1660
# command. Doxygen will then run the mscgen tool (see
3907
1661
# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the
3908
1662
# documentation. The MSCGEN_PATH tag allows you to specify the directory where
3909
1663
# the mscgen tool resides. If left empty the tool is assumed to be found in the
3910
1664
# default search path.
3911
1665
3912
1666
MSCGEN_PATH            =
3913
1667
3914
1668
# If set to YES, the inheritance and collaboration graphs will hide
3915
1669
# inheritance and usage relations if the target is undocumented
3916
1670
# or is not a class.
3917
1671
3918
1672
HIDE_UNDOC_RELATIONS   = NO
3919
1673
3920
1674
# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
3921
1675
# available from the path. This tool is part of Graphviz, a graph visualization
3922
1676
# toolkit from AT&T and Lucent Bell Labs. The other options in this section
3923
1677
# have no effect if this option is set to NO (the default)
3924
1678
3925
1679
HAVE_DOT               = YES
3926
1680
3927
1681
# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is
3928
1682
# allowed to run in parallel. When set to 0 (the default) doxygen will
3929
1683
# base this on the number of processors available in the system. You can set it
3930
1684
# explicitly to a value larger than 0 to get control over the balance
3931
1685
# between CPU load and processing speed.
3932
1686
3933
1687
DOT_NUM_THREADS        = 0
3934
1688
3935
1689
# By default doxygen will use the Helvetica font for all dot files that
3936
1690
# doxygen generates. When you want a differently looking font you can specify
3937
1691
# the font name using DOT_FONTNAME. You need to make sure dot is able to find
3938
1692
# the font, which can be done by putting it in a standard location or by setting
3939
1693
# the DOTFONTPATH environment variable or by setting DOT_FONTPATH to the
3940
1694
# directory containing the font.
3941
1695
3942
1696
DOT_FONTNAME           = Helvetica
3943
1697
3944
1698
# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs.
3945
1699
# The default size is 10pt.
3946
1700
3947
1701
DOT_FONTSIZE           = 10
3948
1702
3949
1703
# By default doxygen will tell dot to use the Helvetica font.
3950
1704
# If you specify a different font using DOT_FONTNAME you can use DOT_FONTPATH to
3951
1705
# set the path where dot can find it.
3952
1706
3953
1707
DOT_FONTPATH           =
3954
1708
3955
1709
# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
3956
1710
# will generate a graph for each documented class showing the direct and
3957
1711
# indirect inheritance relations. Setting this tag to YES will force the
3958
1712
# CLASS_DIAGRAMS tag to NO.
3959
1713
3960
1714
CLASS_GRAPH            = YES
3961
1715
3962
1716
# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
3963
1717
# will generate a graph for each documented class showing the direct and
3964
1718
# indirect implementation dependencies (inheritance, containment, and
3965
1719
# class references variables) of the class with other documented classes.
3966
1720
3967
1721
COLLABORATION_GRAPH    = YES
3968
1722
3969
1723
# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
3970
1724
# will generate a graph for groups, showing the direct groups dependencies
3971
1725
3972
1726
GROUP_GRAPHS           = YES
3973
1727
3974
1728
# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
3975
1729
# collaboration diagrams in a style similar to the OMG's Unified Modeling
3976
1730
# Language.
3977
1731
3978
1732
UML_LOOK               = YES
3979
1733
3980
1734
# If the UML_LOOK tag is enabled, the fields and methods are shown inside
3981
1735
# the class node. If there are many fields or methods and many nodes the
3982
1736
# graph may become too big to be useful. The UML_LIMIT_NUM_FIELDS
3983
1737
# threshold limits the number of items for each type to make the size more
3984
1738
# managable. Set this to 0 for no limit. Note that the threshold may be
3985
1739
# exceeded by 50% before the limit is enforced.
3986
1740
3987
1741
UML_LIMIT_NUM_FIELDS   = 10
3988
1742
3989
1743
# If set to YES, the inheritance and collaboration graphs will show the
3990
1744
# relations between templates and their instances.
3991
1745
3992
1746
TEMPLATE_RELATIONS     = NO
3993
1747
3994
1748
# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
3995
1749
# tags are set to YES then doxygen will generate a graph for each documented
3996
1750
# file showing the direct and indirect include dependencies of the file with
3997
1751
# other documented files.
3998
1752
3999
1753
INCLUDE_GRAPH          = YES
4000
1754
4001
1755
# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
4002
1756
# HAVE_DOT tags are set to YES then doxygen will generate a graph for each
4003
1757
# documented header file showing the documented files that directly or
4004
1758
# indirectly include this file.
4005
1759
4006
1760
INCLUDED_BY_GRAPH      = YES
4007
1761
4008
1762
# If the CALL_GRAPH and HAVE_DOT options are set to YES then
4009
1763
# doxygen will generate a call dependency graph for every global function
4010
1764
# or class method. Note that enabling this option will significantly increase
4011
1765
# the time of a run. So in most cases it will be better to enable call graphs
4012
1766
# for selected functions only using the \callgraph command.
4013
1767
4014
1768
CALL_GRAPH             = YES
4015
1769
4016
1770
# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then
4017
1771
# doxygen will generate a caller dependency graph for every global function
4018
1772
# or class method. Note that enabling this option will significantly increase
4019
1773
# the time of a run. So in most cases it will be better to enable caller
4020
1774
# graphs for selected functions only using the \callergraph command.
4021
1775
4022
1776
CALLER_GRAPH           = NO
4023
1777
4024
1778
# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
4025
1779
# will generate a graphical hierarchy of all classes instead of a textual one.
4026
1780
4027
1781
GRAPHICAL_HIERARCHY    = YES
4028
1782
4029
1783
# If the DIRECTORY_GRAPH and HAVE_DOT tags are set to YES
4030
1784
# then doxygen will show the dependencies a directory has on other directories
4031
1785
# in a graphical way. The dependency relations are determined by the #include
4032
1786
# relations between the files in the directories.
4033
1787
4034
1788
DIRECTORY_GRAPH        = YES
4035
1789
4036
1790
# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
4037
1791
# generated by dot. Possible values are svg, png, jpg, or gif.
4038
1792
# If left blank png will be used. If you choose svg you need to set
4039
1793
# HTML_FILE_EXTENSION to xhtml in order to make the SVG files
4040
1794
# visible in IE 9+ (other browsers do not have this requirement).
4041
1795
4042
1796
DOT_IMAGE_FORMAT       = png
4043
1797
4044
1798
# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
4045
1799
# enable generation of interactive SVG images that allow zooming and panning.
4046
1800
# Note that this requires a modern browser other than Internet Explorer.
4047
1801
# Tested and working are Firefox, Chrome, Safari, and Opera. For IE 9+ you
4048
1802
# need to set HTML_FILE_EXTENSION to xhtml in order to make the SVG files
4049
1803
# visible. Older versions of IE do not have SVG support.
4050
1804
4051
1805
INTERACTIVE_SVG        = YES
4052
1806
4053
1807
# The tag DOT_PATH can be used to specify the path where the dot tool can be
4054
1808
# found. If left blank, it is assumed the dot tool can be found in the path.
4055
1809
4056
1810
DOT_PATH               =
4057
1811
4058
1812
# The DOTFILE_DIRS tag can be used to specify one or more directories that
4059
1813
# contain dot files that are included in the documentation (see the
4060
1814
# \dotfile command).
4061
1815
4062
1816
DOTFILE_DIRS           =
4063
1817
4064
1818
# The MSCFILE_DIRS tag can be used to specify one or more directories that
4065
1819
# contain msc files that are included in the documentation (see the
4066
1820
# \mscfile command).
4067
1821
4068
1822
MSCFILE_DIRS           =
4069
1823
4070
1824
# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
4071
1825
# nodes that will be shown in the graph. If the number of nodes in a graph
4072
1826
# becomes larger than this value, doxygen will truncate the graph, which is
4073
1827
# visualized by representing a node as a red box. Note that doxygen if the
4074
1828
# number of direct children of the root node in a graph is already larger than
4075
1829
# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note
4076
1830
# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
4077
1831
4078
1832
DOT_GRAPH_MAX_NODES    = 50
4079
1833
4080
1834
# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
4081
1835
# graphs generated by dot. A depth value of 3 means that only nodes reachable
4082
1836
# from the root by following a path via at most 3 edges will be shown. Nodes
4083
1837
# that lay further from the root node will be omitted. Note that setting this
4084
1838
# option to 1 or 2 may greatly reduce the computation time needed for large
4085
1839
# code bases. Also note that the size of a graph can be further restricted by
4086
1840
# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
4087
1841
4088
1842
MAX_DOT_GRAPH_DEPTH    = 0
4089
1843
4090
1844
# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
4091
1845
# background. This is disabled by default, because dot on Windows does not
4092
1846
# seem to support this out of the box. Warning: Depending on the platform used,
4093
1847
# enabling this option may lead to badly anti-aliased labels on the edges of
4094
1848
# a graph (i.e. they become hard to read).
4095
1849
4096
1850
DOT_TRANSPARENT        = YES
4097
1851
4098
1852
# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
4099
1853
# files in one run (i.e. multiple -o and -T options on the command line). This
4100
1854
# makes dot run faster, but since only newer versions of dot (>1.8.10)
4101
1855
# support this, this feature is disabled by default.
4102
1856
4103
1857
DOT_MULTI_TARGETS      = YES
4104
1858
4105
1859
# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
4106
1860
# generate a legend page explaining the meaning of the various boxes and
4107
1861
# arrows in the dot generated graphs.
4108
1862
4109
1863
GENERATE_LEGEND        = YES
4110
1864
4111
1865
# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
4112
1866
# remove the intermediate dot files that are used to generate
4113
1867
# the various graphs.
4114
1868
4115
1869
DOT_CLEANUP            = YES
4116
1870
0
4117
=== added directory 'doc/dbus'
4118
=== added file 'doc/dbus/connectivity-api.txt'
4119
--- doc/dbus/connectivity-api.txt	1970-01-01 00:00:00 +0000
4120
+++ doc/dbus/connectivity-api.txt	2014-08-21 18:21:03 +0000
4121
@@ -0,0 +1,26 @@
4122
1
Service		com.ubuntu.connectivity1
4123
2
Interface	com.ubuntu.connectivity1.NetworkingStatus
4124
3
Object path	/com/ubuntu/connectivity1/NetworkingStatus
4125
4
Policy group	connectivity
4126
5
Supports	org.freedesktop.DBus.Introspectable
4127
6
		org.freedesktop.DBus.Properties
4128
7
4129
8
Properties	array{string} Limitations [readonly]
4130
9
4131
10
			String array representing the possible limitations
4132
11
			on networking.
4133
12
4134
13
			Currently available limitations are:
4135
14
				"bandwith"
4136
15
4137
16
			"bandwith" - indicates that the bandwith of the
4138
17
				Internet connection has limitations.
4139
18
				Applications should minimize their bandwith
4140
19
				usage if possible.
4141
20
4142
21
		string Status [readonly]
4143
22
4144
23
			Status of the Internet connectivity. 
4145
24
4146
25
			Possible values:
4147
26
				"offline", "connecting", "online"
4148
0
27
4149
=== removed directory 'doc/pages'
4150
=== removed file 'doc/pages/mainpage.dox'
4151
--- doc/pages/mainpage.dox	2014-03-11 12:20:55 +0000
4152
+++ doc/pages/mainpage.dox	1970-01-01 00:00:00 +0000
4153
@@ -1,23 +0,0 @@
4154
1
/*!
4155
2
\mainpage Ubuntu Connectivity API
4156
3
4157
4
\tableofcontents
4158
5
4159
6
\section sec_introduction Introduction
4160
7
4161
8
Ubuntu API offers a way to access the connectivity related information of the system.
4162
9
4163
10
\subsection sec_thread_safety Note on thread safety
4164
11
4165
12
The API implementation uses a worker thread. The property changes may be dispatched from this thread and thus the
4166
13
user of this API must make sure to handle necessary threading issues.
4167
14
4168
15
\section sec_general General Topics
4169
16
4170
17
 - \ref using-cpp "Using this C++ API"
4171
18
 - \ref networking-status "Getting the networking status."
4172
19
4173
20
\section sec_bug_reports Reporting Bugs
4174
21
If you find any problems with the or this documentation,
4175
22
please file a bug in Connectivity API [Launchpad page](https://bugs.launchpad.net/connectivity-api).
4176
23
*/
4177
24
0
4178
=== removed file 'doc/pages/networking-status.dox'
4179
--- doc/pages/networking-status.dox	2014-03-11 14:19:31 +0000
4180
+++ doc/pages/networking-status.dox	1970-01-01 00:00:00 +0000
4181
@@ -1,31 +0,0 @@
4182
1
/*!
4183
2
\page networking-status Networking Status
4184
3
4185
4
Applications needing to access the overall system networking status can access the
4186
5
top level com::ubuntu::connectivity::networking::Manager class. The class has properties
4187
6
for the networking status and connection characteristics of the system networking.
4188
7
4189
8
\section Setup
4190
9
4191
10
Manager is accessed by including the appropriate header:
4192
11
\snippet example_networking_status.cpp include
4193
12
4194
13
and then creating an instance of the manager:
4195
14
\snippet example_networking_status.cpp create manager
4196
15
4197
16
\section sec_networking_status Networking Status
4198
17
4199
18
The status of the system networking can be accessed through the Manager::status property:
4200
19
\snippet example_networking_status.cpp subscribe networking status changes
4201
20
4202
21
\section sec_characteristics Networking Characteristics
4203
22
4204
23
The characteristics can be accessed through the Manager::characteristics property
4205
24
as a bitfield:
4206
25
\snippet example_networking_status.cpp subscribe characteristics changes
4207
26
4208
27
---
4209
28
The complete example (found in <i>examples/example_networking_status.cpp</i>):
4210
29
\include example_networking_status.cpp
4211
30
4212
31
*/
4213
32
0
4214
=== removed file 'doc/pages/using.dox'
4215
--- doc/pages/using.dox	2014-03-11 12:20:55 +0000
4216
+++ doc/pages/using.dox	1970-01-01 00:00:00 +0000
4217
@@ -1,23 +0,0 @@
4218
1
/*!
4219
2
\page using-cpp Using the C++ API
4220
3
4221
4
Install the development headers:
4222
5
4223
6
\code{.txt}
4224
7
sudo apt-get install libconnectivity-cpp-dev
4225
8
\endcode
4226
9
4227
10
Enable c++11 and use pkg-config to get the necessary compilation flags:
4228
11
4229
12
\code{.txt}
4230
13
$ g++ myapp.cpp -std=c++11 `pkg-config --cflags --libs connectivity-cpp` -o myapp
4231
14
\endcode
4232
15
4233
16
The headers can then be included as:
4234
17
4235
18
\code{.cpp}
4236
19
// includes the com::ubuntu::networking::connectivity::Manager class
4237
20
#include <com/ubuntu/connectivity/networking/manager.h>
4238
21
\endcode
4239
22
4240
23
*/
4241
24
0
4242
=== added directory 'doc/qt'
4243
=== added file 'doc/qt/CMakeLists.txt'
4244
--- doc/qt/CMakeLists.txt	1970-01-01 00:00:00 +0000
4245
+++ doc/qt/CMakeLists.txt	2014-08-21 18:21:03 +0000
4246
@@ -0,0 +1,3 @@
4247
1
add_subdirectory(cpp)
4248
2
add_subdirectory(qml)
4249
3
4250
0
4
4251
=== added directory 'doc/qt/cpp'
4252
=== added file 'doc/qt/cpp/CMakeLists.txt'
4253
--- doc/qt/cpp/CMakeLists.txt	1970-01-01 00:00:00 +0000
4254
+++ doc/qt/cpp/CMakeLists.txt	2014-08-21 18:21:03 +0000
4255
@@ -0,0 +1,40 @@
4256
1
add_subdirectory(examples)
4257
2
4258
3
set(EXTRACT_PRIVATE NO)
4259
4
set(INTERNAL_DOCS NO)
4260
5
set(SOURCE_DIRS "${CMAKE_SOURCE_DIR}/src/qt/include ${CMAKE_CURRENT_SOURCE_DIR}")
4261
6
4262
7
if(${PRIVATE_DOCS})
4263
8
  set(EXTRACT_PRIVATE YES)
4264
9
  set(INTERNAL_DOCS YES)
4265
10
  set(SOURCE_DIRS "${SOURCE_DIRS} ${CMAKE_SOURCE_DIR}/src")
4266
11
endif()
4267
12
4268
13
set(DOC_FILES
4269
14
    Doxyfile.in
4270
15
    pages/mainpage.dox
4271
16
    pages/using.dox
4272
17
    pages/networking-status.dox
4273
18
)
4274
19
4275
20
find_package(Doxygen)
4276
21
if(DOXYGEN_FOUND)
4277
22
    configure_file(
4278
23
        ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in
4279
24
        ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY
4280
25
    )
4281
26
    add_custom_target(cppdoc
4282
27
        ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
4283
28
        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
4284
29
        COMMENT "Generating API documentation with Doxygen" VERBATIM
4285
30
        SOURCES ${DOC_FILES}
4286
31
    )
4287
32
    install(
4288
33
        DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html
4289
34
        DESTINATION ${INSTALL_DOCDIR}/cpp/
4290
35
    )
4291
36
    install(
4292
37
        DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/xml
4293
38
        DESTINATION ${INSTALL_DOCDIR}/cpp/
4294
39
    )
4295
40
endif(DOXYGEN_FOUND)
4296
0
41
4297
=== added file 'doc/qt/cpp/Doxyfile.in'
4298
--- doc/qt/cpp/Doxyfile.in	1970-01-01 00:00:00 +0000
4299
+++ doc/qt/cpp/Doxyfile.in	2014-08-21 18:21:03 +0000
4300
@@ -0,0 +1,2316 @@
4301
1
# Doxyfile 1.8.7
4302
2
4303
3
# This file describes the settings to be used by the documentation system
4304
4
# doxygen (www.doxygen.org) for a project.
4305
5
#
4306
6
# All text after a double hash (##) is considered a comment and is placed in
4307
7
# front of the TAG it is preceding.
4308
8
#
4309
9
# All text after a single hash (#) is considered a comment and will be ignored.
4310
10
# The format is:
4311
11
# TAG = value [value, ...]
4312
12
# For lists, items can also be appended using:
4313
13
# TAG += value [value, ...]
4314
14
# Values that contain spaces should be placed between quotes (\" \").
4315
15
4316
16
#---------------------------------------------------------------------------
4317
17
# Project related configuration options
4318
18
#---------------------------------------------------------------------------
4319
19
4320
20
# This tag specifies the encoding used for all characters in the config file
4321
21
# that follow. The default is UTF-8 which is also the encoding used for all text
4322
22
# before the first occurrence of this tag. Doxygen uses libiconv (or the iconv
4323
23
# built into libc) for the transcoding. See http://www.gnu.org/software/libiconv
4324
24
# for the list of possible encodings.
4325
25
# The default value is: UTF-8.
4326
26
4327
27
DOXYFILE_ENCODING      = UTF-8
4328
28
4329
29
# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
4330
30
# double-quotes, unless you are using Doxywizard) that should identify the
4331
31
# project for which the documentation is generated. This name is used in the
4332
32
# title of most generated pages and in a few other places.
4333
33
# The default value is: My Project.
4334
34
4335
35
PROJECT_NAME           = "Ubuntu Connectivity Qt API"
4336
36
4337
37
# The PROJECT_NUMBER tag can be used to enter a project or revision number. This
4338
38
# could be handy for archiving the generated documentation or if some version
4339
39
# control system is used.
4340
40
4341
41
PROJECT_NUMBER         = @CONNECTIVITY_QT_VERSION_MAJOR@.@CONNECTIVITY_QT_VERSION_MINOR@
4342
42
4343
43
# Using the PROJECT_BRIEF tag one can provide an optional one line description
4344
44
# for a project that appears at the top of each page and should give viewer a
4345
45
# quick idea about the purpose of the project. Keep the description short.
4346
46
4347
47
PROJECT_BRIEF          =
4348
48
4349
49
# With the PROJECT_LOGO tag one can specify an logo or icon that is included in
4350
50
# the documentation. The maximum height of the logo should not exceed 55 pixels
4351
51
# and the maximum width should not exceed 200 pixels. Doxygen will copy the logo
4352
52
# to the output directory.
4353
53
4354
54
PROJECT_LOGO           =
4355
55
4356
56
# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
4357
57
# into which the generated documentation will be written. If a relative path is
4358
58
# entered, it will be relative to the location where doxygen was started. If
4359
59
# left blank the current directory will be used.
4360
60
4361
61
OUTPUT_DIRECTORY       =
4362
62
4363
63
# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 4096 sub-
4364
64
# directories (in 2 levels) under the output directory of each output format and
4365
65
# will distribute the generated files over these directories. Enabling this
4366
66
# option can be useful when feeding doxygen a huge amount of source files, where
4367
67
# putting all generated files in the same directory would otherwise causes
4368
68
# performance problems for the file system.
4369
69
# The default value is: NO.
4370
70
4371
71
CREATE_SUBDIRS         = NO
4372
72
4373
73
# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
4374
74
# characters to appear in the names of generated files. If set to NO, non-ASCII
4375
75
# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
4376
76
# U+3044.
4377
77
# The default value is: NO.
4378
78
4379
79
ALLOW_UNICODE_NAMES    = NO
4380
80
4381
81
# The OUTPUT_LANGUAGE tag is used to specify the language in which all
4382
82
# documentation generated by doxygen is written. Doxygen will use this
4383
83
# information to generate all constant output in the proper language.
4384
84
# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,
4385
85
# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),
4386
86
# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,
4387
87
# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),
4388
88
# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,
4389
89
# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,
4390
90
# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,
4391
91
# Ukrainian and Vietnamese.
4392
92
# The default value is: English.
4393
93
4394
94
OUTPUT_LANGUAGE        = English
4395
95
4396
96
# If the BRIEF_MEMBER_DESC tag is set to YES doxygen will include brief member
4397
97
# descriptions after the members that are listed in the file and class
4398
98
# documentation (similar to Javadoc). Set to NO to disable this.
4399
99
# The default value is: YES.
4400
100
4401
101
BRIEF_MEMBER_DESC      = YES
4402
102
4403
103
# If the REPEAT_BRIEF tag is set to YES doxygen will prepend the brief
4404
104
# description of a member or function before the detailed description
4405
105
#
4406
106
# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
4407
107
# brief descriptions will be completely suppressed.
4408
108
# The default value is: YES.
4409
109
4410
110
REPEAT_BRIEF           = YES
4411
111
4412
112
# This tag implements a quasi-intelligent brief description abbreviator that is
4413
113
# used to form the text in various listings. Each string in this list, if found
4414
114
# as the leading text of the brief description, will be stripped from the text
4415
115
# and the result, after processing the whole list, is used as the annotated
4416
116
# text. Otherwise, the brief description is used as-is. If left blank, the
4417
117
# following values are used ($name is automatically replaced with the name of
4418
118
# the entity):The $name class, The $name widget, The $name file, is, provides,
4419
119
# specifies, contains, represents, a, an and the.
4420
120
4421
121
ABBREVIATE_BRIEF       =
4422
122
4423
123
# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
4424
124
# doxygen will generate a detailed section even if there is only a brief
4425
125
# description.
4426
126
# The default value is: NO.
4427
127
4428
128
ALWAYS_DETAILED_SEC    = NO
4429
129
4430
130
# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
4431
131
# inherited members of a class in the documentation of that class as if those
4432
132
# members were ordinary class members. Constructors, destructors and assignment
4433
133
# operators of the base classes will not be shown.
4434
134
# The default value is: NO.
4435
135
4436
136
INLINE_INHERITED_MEMB  = NO
4437
137
4438
138
# If the FULL_PATH_NAMES tag is set to YES doxygen will prepend the full path
4439
139
# before files name in the file list and in the header files. If set to NO the
4440
140
# shortest path that makes the file name unique will be used
4441
141
# The default value is: YES.
4442
142
4443
143
FULL_PATH_NAMES        = NO
4444
144
4445
145
# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
4446
146
# Stripping is only done if one of the specified strings matches the left-hand
4447
147
# part of the path. The tag can be used to show relative paths in the file list.
4448
148
# If left blank the directory from which doxygen is run is used as the path to
4449
149
# strip.
4450
150
#
4451
151
# Note that you can specify absolute paths here, but also relative paths, which
4452
152
# will be relative from the directory where doxygen is started.
4453
153
# This tag requires that the tag FULL_PATH_NAMES is set to YES.
4454
154
4455
155
STRIP_FROM_PATH        =
4456
156
4457
157
# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
4458
158
# path mentioned in the documentation of a class, which tells the reader which
4459
159
# header file to include in order to use a class. If left blank only the name of
4460
160
# the header file containing the class definition is used. Otherwise one should
4461
161
# specify the list of include paths that are normally passed to the compiler
4462
162
# using the -I flag.
4463
163
4464
164
STRIP_FROM_INC_PATH    = @CMAKE_SOURCE_DIR@/src/qt/include
4465
165
4466
166
# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
4467
167
# less readable) file names. This can be useful is your file systems doesn't
4468
168
# support long names like on DOS, Mac, or CD-ROM.
4469
169
# The default value is: NO.
4470
170
4471
171
SHORT_NAMES            = NO
4472
172
4473
173
# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the
4474
174
# first line (until the first dot) of a Javadoc-style comment as the brief
4475
175
# description. If set to NO, the Javadoc-style will behave just like regular Qt-
4476
176
# style comments (thus requiring an explicit @brief command for a brief
4477
177
# description.)
4478
178
# The default value is: NO.
4479
179
4480
180
JAVADOC_AUTOBRIEF      = NO
4481
181
4482
182
# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
4483
183
# line (until the first dot) of a Qt-style comment as the brief description. If
4484
184
# set to NO, the Qt-style will behave just like regular Qt-style comments (thus
4485
185
# requiring an explicit \brief command for a brief description.)
4486
186
# The default value is: NO.
4487
187
4488
188
QT_AUTOBRIEF           = NO
4489
189
4490
190
# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a
4491
191
# multi-line C++ special comment block (i.e. a block of //! or /// comments) as
4492
192
# a brief description. This used to be the default behavior. The new default is
4493
193
# to treat a multi-line C++ comment block as a detailed description. Set this
4494
194
# tag to YES if you prefer the old behavior instead.
4495
195
#
4496
196
# Note that setting this tag to YES also means that rational rose comments are
4497
197
# not recognized any more.
4498
198
# The default value is: NO.
4499
199
4500
200
MULTILINE_CPP_IS_BRIEF = NO
4501
201
4502
202
# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
4503
203
# documentation from any documented member that it re-implements.
4504
204
# The default value is: YES.
4505
205
4506
206
INHERIT_DOCS           = YES
4507
207
4508
208
# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce a
4509
209
# new page for each member. If set to NO, the documentation of a member will be
4510
210
# part of the file/class/namespace that contains it.
4511
211
# The default value is: NO.
4512
212
4513
213
SEPARATE_MEMBER_PAGES  = NO
4514
214
4515
215
# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen
4516
216
# uses this value to replace tabs by spaces in code fragments.
4517
217
# Minimum value: 1, maximum value: 16, default value: 4.
4518
218
4519
219
TAB_SIZE               = 4
4520
220
4521
221
# This tag can be used to specify a number of aliases that act as commands in
4522
222
# the documentation. An alias has the form:
4523
223
# name=value
4524
224
# For example adding
4525
225
# "sideeffect=@par Side Effects:\n"
4526
226
# will allow you to put the command \sideeffect (or @sideeffect) in the
4527
227
# documentation, which will result in a user-defined paragraph with heading
4528
228
# "Side Effects:". You can put \n's in the value part of an alias to insert
4529
229
# newlines.
4530
230
4531
231
ALIASES                = "accessors=\par Accessors:\n" \
4532
232
                         "initvalue=\par Initial Value:\n" \
4533
233
                         "notify=\par Notify:\n"
4534
234
4535
235
# This tag can be used to specify a number of word-keyword mappings (TCL only).
4536
236
# A mapping has the form "name=value". For example adding "class=itcl::class"
4537
237
# will allow you to use the command class in the itcl::class meaning.
4538
238
4539
239
TCL_SUBST              =
4540
240
4541
241
# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
4542
242
# only. Doxygen will then generate output that is more tailored for C. For
4543
243
# instance, some of the names that are used will be different. The list of all
4544
244
# members will be omitted, etc.
4545
245
# The default value is: NO.
4546
246
4547
247
OPTIMIZE_OUTPUT_FOR_C  = NO
4548
248
4549
249
# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
4550
250
# Python sources only. Doxygen will then generate output that is more tailored
4551
251
# for that language. For instance, namespaces will be presented as packages,
4552
252
# qualified scopes will look different, etc.
4553
253
# The default value is: NO.
4554
254
4555
255
OPTIMIZE_OUTPUT_JAVA   = NO
4556
256
4557
257
# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
4558
258
# sources. Doxygen will then generate output that is tailored for Fortran.
4559
259
# The default value is: NO.
4560
260
4561
261
OPTIMIZE_FOR_FORTRAN   = NO
4562
262
4563
263
# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
4564
264
# sources. Doxygen will then generate output that is tailored for VHDL.
4565
265
# The default value is: NO.
4566
266
4567
267
OPTIMIZE_OUTPUT_VHDL   = NO
4568
268
4569
269
# Doxygen selects the parser to use depending on the extension of the files it
4570
270
# parses. With this tag you can assign which parser to use for a given
4571
271
# extension. Doxygen has a built-in mapping, but you can override or extend it
4572
272
# using this tag. The format is ext=language, where ext is a file extension, and
4573
273
# language is one of the parsers supported by doxygen: IDL, Java, Javascript,
4574
274
# C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran:
4575
275
# FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran:
4576
276
# Fortran. In the later case the parser tries to guess whether the code is fixed
4577
277
# or free formatted code, this is the default for Fortran type files), VHDL. For
4578
278
# instance to make doxygen treat .inc files as Fortran files (default is PHP),
4579
279
# and .f files as C (default is Fortran), use: inc=Fortran f=C.
4580
280
#
4581
281
# Note For files without extension you can use no_extension as a placeholder.
4582
282
#
4583
283
# Note that for custom extensions you also need to set FILE_PATTERNS otherwise
4584
284
# the files are not read by doxygen.
4585
285
4586
286
EXTENSION_MAPPING      =
4587
287
4588
288
# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
4589
289
# according to the Markdown format, which allows for more readable
4590
290
# documentation. See http://daringfireball.net/projects/markdown/ for details.
4591
291
# The output of markdown processing is further processed by doxygen, so you can
4592
292
# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
4593
293
# case of backward compatibilities issues.
4594
294
# The default value is: YES.
4595
295
4596
296
MARKDOWN_SUPPORT       = YES
4597
297
4598
298
# When enabled doxygen tries to link words that correspond to documented
4599
299
# classes, or namespaces to their corresponding documentation. Such a link can
4600
300
# be prevented in individual cases by by putting a % sign in front of the word
4601
301
# or globally by setting AUTOLINK_SUPPORT to NO.
4602
302
# The default value is: YES.
4603
303
4604
304
AUTOLINK_SUPPORT       = YES
4605
305
4606
306
# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
4607
307
# to include (a tag file for) the STL sources as input, then you should set this
4608
308
# tag to YES in order to let doxygen match functions declarations and
4609
309
# definitions whose arguments contain STL classes (e.g. func(std::string);
4610
310
# versus func(std::string) {}). This also make the inheritance and collaboration
4611
311
# diagrams that involve STL classes more complete and accurate.
4612
312
# The default value is: NO.
4613
313
4614
314
BUILTIN_STL_SUPPORT    = YES
4615
315
4616
316
# If you use Microsoft's C++/CLI language, you should set this option to YES to
4617
317
# enable parsing support.
4618
318
# The default value is: NO.
4619
319
4620
320
CPP_CLI_SUPPORT        = NO
4621
321
4622
322
# Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
4623
323
# http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen
4624
324
# will parse them like normal C++ but will assume all classes use public instead
4625
325
# of private inheritance when no explicit protection keyword is present.
4626
326
# The default value is: NO.
4627
327
4628
328
SIP_SUPPORT            = NO
4629
329
4630
330
# For Microsoft's IDL there are propget and propput attributes to indicate
4631
331
# getter and setter methods for a property. Setting this option to YES will make
4632
332
# doxygen to replace the get and set methods by a property in the documentation.
4633
333
# This will only work if the methods are indeed getting or setting a simple
4634
334
# type. If this is not the case, or you want to show the methods anyway, you
4635
335
# should set this option to NO.
4636
336
# The default value is: YES.
4637
337
4638
338
IDL_PROPERTY_SUPPORT   = YES
4639
339
4640
340
# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
4641
341
# tag is set to YES, then doxygen will reuse the documentation of the first
4642
342
# member in the group (if any) for the other members of the group. By default
4643
343
# all members of a group must be documented explicitly.
4644
344
# The default value is: NO.
4645
345
4646
346
DISTRIBUTE_GROUP_DOC   = NO
4647
347
4648
348
# Set the SUBGROUPING tag to YES to allow class member groups of the same type
4649
349
# (for instance a group of public functions) to be put as a subgroup of that
4650
350
# type (e.g. under the Public Functions section). Set it to NO to prevent
4651
351
# subgrouping. Alternatively, this can be done per class using the
4652
352
# \nosubgrouping command.
4653
353
# The default value is: YES.
4654
354
4655
355
SUBGROUPING            = YES
4656
356
4657
357
# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
4658
358
# are shown inside the group in which they are included (e.g. using \ingroup)
4659
359
# instead of on a separate page (for HTML and Man pages) or section (for LaTeX
4660
360
# and RTF).
4661
361
#
4662
362
# Note that this feature does not work in combination with
4663
363
# SEPARATE_MEMBER_PAGES.
4664
364
# The default value is: NO.
4665
365
4666
366
INLINE_GROUPED_CLASSES = NO
4667
367
4668
368
# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
4669
369
# with only public data fields or simple typedef fields will be shown inline in
4670
370
# the documentation of the scope in which they are defined (i.e. file,
4671
371
# namespace, or group documentation), provided this scope is documented. If set
4672
372
# to NO, structs, classes, and unions are shown on a separate page (for HTML and
4673
373
# Man pages) or section (for LaTeX and RTF).
4674
374
# The default value is: NO.
4675
375
4676
376
INLINE_SIMPLE_STRUCTS  = NO
4677
377
4678
378
# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or
4679
379
# enum is documented as struct, union, or enum with the name of the typedef. So
4680
380
# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
4681
381
# with name TypeT. When disabled the typedef will appear as a member of a file,
4682
382
# namespace, or class. And the struct will be named TypeS. This can typically be
4683
383
# useful for C code in case the coding convention dictates that all compound
4684
384
# types are typedef'ed and only the typedef is referenced, never the tag name.
4685
385
# The default value is: NO.
4686
386
4687
387
TYPEDEF_HIDES_STRUCT   = NO
4688
388
4689
389
# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
4690
390
# cache is used to resolve symbols given their name and scope. Since this can be
4691
391
# an expensive process and often the same symbol appears multiple times in the
4692
392
# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small
4693
393
# doxygen will become slower. If the cache is too large, memory is wasted. The
4694
394
# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range
4695
395
# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536
4696
396
# symbols. At the end of a run doxygen will report the cache usage and suggest
4697
397
# the optimal cache size from a speed point of view.
4698
398
# Minimum value: 0, maximum value: 9, default value: 0.
4699
399
4700
400
LOOKUP_CACHE_SIZE      = 0
4701
401
4702
402
#---------------------------------------------------------------------------
4703
403
# Build related configuration options
4704
404
#---------------------------------------------------------------------------
4705
405
4706
406
# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
4707
407
# documentation are documented, even if no documentation was available. Private
4708
408
# class members and static file members will be hidden unless the
4709
409
# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES.
4710
410
# Note: This will also disable the warnings about undocumented members that are
4711
411
# normally produced when WARNINGS is set to YES.
4712
412
# The default value is: NO.
4713
413
4714
414
EXTRACT_ALL            = YES
4715
415
4716
416
# If the EXTRACT_PRIVATE tag is set to YES all private members of a class will
4717
417
# be included in the documentation.
4718
418
# The default value is: NO.
4719
419
4720
420
EXTRACT_PRIVATE        = @EXTRACT_PRIVATE@
4721
421
4722
422
# If the EXTRACT_PACKAGE tag is set to YES all members with package or internal
4723
423
# scope will be included in the documentation.
4724
424
# The default value is: NO.
4725
425
4726
426
EXTRACT_PACKAGE        = NO
4727
427
4728
428
# If the EXTRACT_STATIC tag is set to YES all static members of a file will be
4729
429
# included in the documentation.
4730
430
# The default value is: NO.
4731
431
4732
432
EXTRACT_STATIC         = YES
4733
433
4734
434
# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) defined
4735
435
# locally in source files will be included in the documentation. If set to NO
4736
436
# only classes defined in header files are included. Does not have any effect
4737
437
# for Java sources.
4738
438
# The default value is: YES.
4739
439
4740
440
EXTRACT_LOCAL_CLASSES  = YES
4741
441
4742
442
# This flag is only useful for Objective-C code. When set to YES local methods,
4743
443
# which are defined in the implementation section but not in the interface are
4744
444
# included in the documentation. If set to NO only methods in the interface are
4745
445
# included.
4746
446
# The default value is: NO.
4747
447
4748
448
EXTRACT_LOCAL_METHODS  = NO
4749
449
4750
450
# If this flag is set to YES, the members of anonymous namespaces will be
4751
451
# extracted and appear in the documentation as a namespace called
4752
452
# 'anonymous_namespace{file}', where file will be replaced with the base name of
4753
453
# the file that contains the anonymous namespace. By default anonymous namespace
4754
454
# are hidden.
4755
455
# The default value is: NO.
4756
456
4757
457
EXTRACT_ANON_NSPACES   = NO
4758
458
4759
459
# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
4760
460
# undocumented members inside documented classes or files. If set to NO these
4761
461
# members will be included in the various overviews, but no documentation
4762
462
# section is generated. This option has no effect if EXTRACT_ALL is enabled.
4763
463
# The default value is: NO.
4764
464
4765
465
HIDE_UNDOC_MEMBERS     = NO
4766
466
4767
467
# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
4768
468
# undocumented classes that are normally visible in the class hierarchy. If set
4769
469
# to NO these classes will be included in the various overviews. This option has
4770
470
# no effect if EXTRACT_ALL is enabled.
4771
471
# The default value is: NO.
4772
472
4773
473
HIDE_UNDOC_CLASSES     = NO
4774
474
4775
475
# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
4776
476
# (class|struct|union) declarations. If set to NO these declarations will be
4777
477
# included in the documentation.
4778
478
# The default value is: NO.
4779
479
4780
480
HIDE_FRIEND_COMPOUNDS  = YES
4781
481
4782
482
# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any
4783
483
# documentation blocks found inside the body of a function. If set to NO these
4784
484
# blocks will be appended to the function's detailed documentation block.
4785
485
# The default value is: NO.
4786
486
4787
487
HIDE_IN_BODY_DOCS      = NO
4788
488
4789
489
# The INTERNAL_DOCS tag determines if documentation that is typed after a
4790
490
# \internal command is included. If the tag is set to NO then the documentation
4791
491
# will be excluded. Set it to YES to include the internal documentation.
4792
492
# The default value is: NO.
4793
493
4794
494
INTERNAL_DOCS          = @INTERNAL_DOCS@
4795
495
4796
496
# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
4797
497
# names in lower-case letters. If set to YES upper-case letters are also
4798
498
# allowed. This is useful if you have classes or files whose names only differ
4799
499
# in case and if your file system supports case sensitive file names. Windows
4800
500
# and Mac users are advised to set this option to NO.
4801
501
# The default value is: system dependent.
4802
502
4803
503
CASE_SENSE_NAMES       = YES
4804
504
4805
505
# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
4806
506
# their full class and namespace scopes in the documentation. If set to YES the
4807
507
# scope will be hidden.
4808
508
# The default value is: NO.
4809
509
4810
510
HIDE_SCOPE_NAMES       = NO
4811
511
4812
512
# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
4813
513
# the files that are included by a file in the documentation of that file.
4814
514
# The default value is: YES.
4815
515
4816
516
SHOW_INCLUDE_FILES     = YES
4817
517
4818
518
# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each
4819
519
# grouped member an include statement to the documentation, telling the reader
4820
520
# which file to include in order to use the member.
4821
521
# The default value is: NO.
4822
522
4823
523
SHOW_GROUPED_MEMB_INC  = NO
4824
524
4825
525
# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include
4826
526
# files with double quotes in the documentation rather than with sharp brackets.
4827
527
# The default value is: NO.
4828
528
4829
529
FORCE_LOCAL_INCLUDES   = NO
4830
530
4831
531
# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the
4832
532
# documentation for inline members.
4833
533
# The default value is: YES.
4834
534
4835
535
INLINE_INFO            = YES
4836
536
4837
537
# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
4838
538
# (detailed) documentation of file and class members alphabetically by member
4839
539
# name. If set to NO the members will appear in declaration order.
4840
540
# The default value is: YES.
4841
541
4842
542
SORT_MEMBER_DOCS       = YES
4843
543
4844
544
# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
4845
545
# descriptions of file, namespace and class members alphabetically by member
4846
546
# name. If set to NO the members will appear in declaration order. Note that
4847
547
# this will also influence the order of the classes in the class list.
4848
548
# The default value is: NO.
4849
549
4850
550
SORT_BRIEF_DOCS        = YES
4851
551
4852
552
# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the
4853
553
# (brief and detailed) documentation of class members so that constructors and
4854
554
# destructors are listed first. If set to NO the constructors will appear in the
4855
555
# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS.
4856
556
# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief
4857
557
# member documentation.
4858
558
# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting
4859
559
# detailed member documentation.
4860
560
# The default value is: NO.
4861
561
4862
562
SORT_MEMBERS_CTORS_1ST = YES
4863
563
4864
564
# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
4865
565
# of group names into alphabetical order. If set to NO the group names will
4866
566
# appear in their defined order.
4867
567
# The default value is: NO.
4868
568
4869
569
SORT_GROUP_NAMES       = NO
4870
570
4871
571
# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
4872
572
# fully-qualified names, including namespaces. If set to NO, the class list will
4873
573
# be sorted only by class name, not including the namespace part.
4874
574
# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
4875
575
# Note: This option applies only to the class list, not to the alphabetical
4876
576
# list.
4877
577
# The default value is: NO.
4878
578
4879
579
SORT_BY_SCOPE_NAME     = NO
4880
580
4881
581
# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper
4882
582
# type resolution of all parameters of a function it will reject a match between
4883
583
# the prototype and the implementation of a member function even if there is
4884
584
# only one candidate or it is obvious which candidate to choose by doing a
4885
585
# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still
4886
586
# accept a match between prototype and implementation in such cases.
4887
587
# The default value is: NO.
4888
588
4889
589
STRICT_PROTO_MATCHING  = NO
4890
590
4891
591
# The GENERATE_TODOLIST tag can be used to enable ( YES) or disable ( NO) the
4892
592
# todo list. This list is created by putting \todo commands in the
4893
593
# documentation.
4894
594
# The default value is: YES.
4895
595
4896
596
GENERATE_TODOLIST      = YES
4897
597
4898
598
# The GENERATE_TESTLIST tag can be used to enable ( YES) or disable ( NO) the
4899
599
# test list. This list is created by putting \test commands in the
4900
600
# documentation.
4901
601
# The default value is: YES.
4902
602
4903
603
GENERATE_TESTLIST      = YES
4904
604
4905
605
# The GENERATE_BUGLIST tag can be used to enable ( YES) or disable ( NO) the bug
4906
606
# list. This list is created by putting \bug commands in the documentation.
4907
607
# The default value is: YES.
4908
608
4909
609
GENERATE_BUGLIST       = YES
4910
610
4911
611
# The GENERATE_DEPRECATEDLIST tag can be used to enable ( YES) or disable ( NO)
4912
612
# the deprecated list. This list is created by putting \deprecated commands in
4913
613
# the documentation.
4914
614
# The default value is: YES.
4915
615
4916
616
GENERATE_DEPRECATEDLIST= YES
4917
617
4918
618
# The ENABLED_SECTIONS tag can be used to enable conditional documentation
4919
619
# sections, marked by \if <section_label> ... \endif and \cond <section_label>
4920
620
# ... \endcond blocks.
4921
621
4922
622
ENABLED_SECTIONS       =
4923
623
4924
624
# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
4925
625
# initial value of a variable or macro / define can have for it to appear in the
4926
626
# documentation. If the initializer consists of more lines than specified here
4927
627
# it will be hidden. Use a value of 0 to hide initializers completely. The
4928
628
# appearance of the value of individual variables and macros / defines can be
4929
629
# controlled using \showinitializer or \hideinitializer command in the
4930
630
# documentation regardless of this setting.
4931
631
# Minimum value: 0, maximum value: 10000, default value: 30.
4932
632
4933
633
MAX_INITIALIZER_LINES  = 30
4934
634
4935
635
# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
4936
636
# the bottom of the documentation of classes and structs. If set to YES the list
4937
637
# will mention the files that were used to generate the documentation.
4938
638
# The default value is: YES.
4939
639
4940
640
SHOW_USED_FILES        = YES
4941
641
4942
642
# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
4943
643
# will remove the Files entry from the Quick Index and from the Folder Tree View
4944
644
# (if specified).
4945
645
# The default value is: YES.
4946
646
4947
647
SHOW_FILES             = YES
4948
648
4949
649
# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
4950
650
# page. This will remove the Namespaces entry from the Quick Index and from the
4951
651
# Folder Tree View (if specified).
4952
652
# The default value is: YES.
4953
653
4954
654
SHOW_NAMESPACES        = YES
4955
655
4956
656
# The FILE_VERSION_FILTER tag can be used to specify a program or script that
4957
657
# doxygen should invoke to get the current version for each file (typically from
4958
658
# the version control system). Doxygen will invoke the program by executing (via
4959
659
# popen()) the command command input-file, where command is the value of the
4960
660
# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided
4961
661
# by doxygen. Whatever the program writes to standard output is used as the file
4962
662
# version. For an example see the documentation.
4963
663
4964
664
FILE_VERSION_FILTER    =
4965
665
4966
666
# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
4967
667
# by doxygen. The layout file controls the global structure of the generated
4968
668
# output files in an output format independent way. To create the layout file
4969
669
# that represents doxygen's defaults, run doxygen with the -l option. You can
4970
670
# optionally specify a file name after the option, if omitted DoxygenLayout.xml
4971
671
# will be used as the name of the layout file.
4972
672
#
4973
673
# Note that if you run doxygen from a directory containing a file called
4974
674
# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
4975
675
# tag is left empty.
4976
676
4977
677
LAYOUT_FILE            =
4978
678
4979
679
# The CITE_BIB_FILES tag can be used to specify one or more bib files containing
4980
680
# the reference definitions. This must be a list of .bib files. The .bib
4981
681
# extension is automatically appended if omitted. This requires the bibtex tool
4982
682
# to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info.
4983
683
# For LaTeX the style of the bibliography can be controlled using
4984
684
# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
4985
685
# search path. Do not use file names with spaces, bibtex cannot handle them. See
4986
686
# also \cite for info how to create references.
4987
687
4988
688
CITE_BIB_FILES         =
4989
689
4990
690
#---------------------------------------------------------------------------
4991
691
# Configuration options related to warning and progress messages
4992
692
#---------------------------------------------------------------------------
4993
693
4994
694
# The QUIET tag can be used to turn on/off the messages that are generated to
4995
695
# standard output by doxygen. If QUIET is set to YES this implies that the
4996
696
# messages are off.
4997
697
# The default value is: NO.
4998
698
4999
699
QUIET                  = NO
5000
700
Reviewer	Review Type	Date Requested	Status
Robert Bruce Park (community)			Approve on 2014-08-21
Timo Jyrinki (community)			Needs Fixing on 2014-08-21
Charles Kerr (community)		2014-08-19	Approve on 2014-08-20
PS Jenkins bot (community)	continuous-integration		Approve on 2014-08-19
Review via email: mp+231431@code.launchpad.net