This file is indexed.

/usr/include/kautostart.h is in kdelibs5-dev 4:4.8.5-0ubuntu0.6.

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

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
/* This file is part of the KDE libraries
    Copyright (C) 2006 Aaron Seigo <aseigo@kde.org>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
*/

#ifndef KDELIBS_KAUTOSTART_H
#define KDELIBS_KAUTOSTART_H

#include <kdecore_export.h>

#include <QtCore/QObject>

class QStringList;

/**
 * KAutostart provides a programmatic means to control the state of
 * autostart services on a per-user basis. This is useful for applications
 * that wish to offer a configurable means to allow the application to be
 * autostarted.
 *
 * By using this class you future-proof your applications against potential
 * future or platform-specific changes to the autostart mechanism(s).
 *
 * Typical usage might look like:
 *
 * @code
 * KAutostart autostart; // without an entryName arg, gets name from KAboutData
 * autostart.setAutostarts(true); // will now start up when the user logs in
 *
 * // set the value in our configuration settings to reflect whether or not
 * // we will actually start up on log in
 * config.setAutoStart(autostart.autoStarts());
 * @endcode
 */
class KDECORE_EXPORT KAutostart : public QObject
{
    Q_OBJECT

    public:
        /**
         * Creates a new KAutostart object that represents the autostart
         * service "entryName". If the service already exists in the system
         * then the values associated with that service, such as the executable
         * command, will be loaded as well.
         *
         * Note that unless this service is explicitly set to autostart,
         * simply creating a KAutostart object will not result in the
         * service being autostarted on next log in.
         *
         * If no such service is already registered and the command to be
         * executed on startup is not the same as entryName, then you will want
         * to set the associated command with setExec(const QString&)
         * @see setExec
         * @param entryName the name used to identify the service. If none is
         *        provided then it uses the name registered with KAboutData.
         * @param parent QObject
         */
        explicit KAutostart(const QString& entryName = QString(),
                            QObject* parent = 0);
        ~KAutostart();

        /**
         * Flags for each of the conditions that may affect whether or not
         * a service actually autostarted on login
         */
        enum Condition
        {
            NoConditions = 0x0,
            /**
             * an executable that is checked for existence by name
             */
            CheckCommand = 0x1,
            /**
             * autostart condition will be checked too (KDE-specific)
             * @since 4.3
             */
            CheckCondition = 0x2,
            /**
             * all necessary conditions will be checked
             * @since 4.3
             */
            CheckAll = 0xff
        };
        Q_DECLARE_FLAGS(Conditions, Condition)

        /**
         * Enumerates the various autostart phases that occur during start-up.
         */
        enum StartPhase
        {
            /**
             * the essential desktop services such as panels and window managers
             */
            BaseDesktop = 0,
            /**
             * services that should be available before most interactive
             * applications start but that aren't part of the base desktop.
             * This would include things such as clipboard managers and
             * mouse gesture tools.
             */
            DesktopServices = 1,
            /**
             * everything else that doesn't belong in the above two categories,
             * including most system tray applications, system monitors and
             * interactive applications
             */
            Applications = 2
        };

        /**
         * Sets the given exec to start automatically at login
         * @param autostart will register with the autostart facility when true
         *        and deregister when false
         * @see autostarts()
         */
        void setAutostarts(bool autostart);

        /**
         * Returns whether or not the service represented by entryName in the
         * autostart system is set to autostart at login or not
         * @param environment if provided the check will be performed as if
         *        being loaded in that environment
         * @param check autostart conditions to check for (see commandToCheck())
         * @see setAutostarts()
         */
        bool autostarts(const QString& environment = QString(),
                        Conditions check = NoConditions) const;

        /**
         * Returns the associated command for this autostart service
         * @see setCommand()
         */
        QString command() const;
        /**
         * Set the associated command for this autostart service
         * @see command()
         */
        void setCommand(const QString& command);

        /**
         * Returns the user-visible name this autostart service is registered as
         * @see setVisibleName(), setEntryName()
         */
        QString visibleName() const;
        /**
         * Sets the user-visible name for this autostart service.
         * @see visibleName()
         */
        void setVisibleName(const QString& entryName);

        /**
         * Checks whether or not a service by the given name @p entryName is registered
         * with the autostart system. Does not check whether or not it is
         * set to actually autostart or not.
         * @param entryName the name of the service to check for
         */
        static bool isServiceRegistered(const QString& entryName);

        /**
         * Returns the executable to check for when attempting to autostart
         * this service. If the executable is not found in the user's
         * environment, it will not autostart.
         * @see setCommandToCheck()
         */
        QString commandToCheck() const;
        /**
         * Sets the executable to check for the existence of when
         * autostarting this service
         * @see commandToCheck()
         */
        void setCommandToCheck(const QString& exec);

        /**
         * Returns the autostart phase this service is started in.
         *
         * Note that this is KDE specific and may not work in other
         * environments.
         *
         * @see StartPhase, setStartPhase()
         */
        StartPhase startPhase() const;
        /**
         * Sets the service (by name) this service should be started after.
         *
         * Note that this is KDE specific and may not work in other
         * environments.
         *
         * @see StartPhase, startPhase()
         */
        void setStartPhase(StartPhase phase);

        /**
         * Returns the list of environments (e.g. "KDE") this service is allowed
         * to start in. Use checkAllowedEnvironment() or autostarts() for actual
         * checks.
         *
         * This does not take other autostart conditions
         * into account. If any environment is added to the allowed environments
         * list, then only those environments will be allowed to
         * autoload the service. It is not allowed to specify both allowed and excluded
         * environments at the same time.
         * @see setAllowedEnvironments()
         */
        QStringList allowedEnvironments() const;
        /**
         * Sets the environments this service is allowed to start in
         * @see allowedEnvironments(), addToAllowedEnvironments()
         */
        void setAllowedEnvironments(const QStringList& environments);
        /**
         * Adds an environment to the list of environments this service may
         * start in.
         * @see setAllowedEnvironments(), removeFromAllowedEnvironments()
         */
        void addToAllowedEnvironments(const QString& environment);
        /**
         * Removes an environment to the list of environments this service may
         * start in.
         * @see addToAllowedEnvironments()
         */
        void removeFromAllowedEnvironments(const QString& environment);

        /**
         * Returns the list of environments this service is explicitly not
         * allowed to start in. Use checkAllowedEnvironment() or autostarts() for actual
         * checks.
         *
         * This does not take other autostart conditions
         * such as into account. It is not allowed to specify both allowed and excluded
         * environments at the same time.
         * @see setExcludedEnvironments()
         */
        QStringList excludedEnvironments() const;
        /**
         * Sets the environments this service is not allowed to start in
         * @see excludedEnvironments(), addToExcludedEnvironments()
         */
        void setExcludedEnvironments(const QStringList& environments);
        /**
         * Adds an environment to the list of environments this service may
         * not be autostarted in
         * @see removeFromExcludedEnvironments()
         */
        void addToExcludedEnvironments(const QString& environment);
        /**
         * Removes an environment to the list of environments this service may
         * not be autostarted in
         * @see addToExcludedEnvironments()
         */
        void removeFromExcludedEnvironments(const QString& environment);

        /**
         * Returns the name of another service that should be autostarted
         * before this one (if that service would be autostarted).
         * @internal
         * @since 4.3
         */
        QString startAfter() const;

        /**
         * Checks whether autostart is allowed in the given environment,
         * depending on allowedEnvironments() and excludedEnvironments().
         * @since 4.3
         */
        bool checkAllowedEnvironment( const QString& environment ) const;

    private:
        bool checkStartCondition() const;
        class Private;
        Private* const d;
};

Q_DECLARE_OPERATORS_FOR_FLAGS(KAutostart::Conditions)
#endif