This file is indexed.

/usr/include/okular/core/pagetransition.h is in okular-dev 4:4.13.0-0ubuntu1.

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
/***************************************************************************
 *   Copyright (C) 2005 by Tobias Koenig <tokoe@kde.org>                   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 ***************************************************************************/

#ifndef _OKULAR_PAGETRANSITION_H_
#define _OKULAR_PAGETRANSITION_H_

#include "okular_export.h"

namespace Okular {

/**
 * @short Information object for the transition effect of a page.
 *
 * This class encapsulates the information about the effect of
 * a page transition. It supports mainly the transition effects as
 * defined in PDF specification 1.6.
 */
class OKULAR_EXPORT PageTransition
{
    public:
        /**
         * Describes the type of transition effect.
         */
        enum Type {
            Replace,
            Split,
            Blinds,
            Box,
            Wipe,
            Dissolve,
            Glitter,
            Fly,
            Push,
            Cover,
            Uncover,
            Fade
        };

        /**
         * Describes the alignment that is applied to the @ref Type
         * of transition effect.
         */
        enum Alignment {
            Horizontal,
            Vertical
        };

        /**
         * Describes the direction that is applied to the @ref Type
         * of transition effect.
         */
        enum Direction {
            Inward,
            Outward
        };

        /**
         * Creates a new page transition of the given @p type.
         *
         * If no type is given, the normal @ref Replace transition is used.
         */
        PageTransition( Type type = Replace );

        /**
         * Creates a new page transition from an @p other.
         */
        PageTransition( const PageTransition &other );
        PageTransition& operator=( const PageTransition &other );

        /**
         * Destroys the page transition.
         */
        ~PageTransition();

        /**
         * Returns the type of the transition.
         */
        Type type() const;

        /**
         * Returns the duration of the transition in seconds.
         */
        int duration() const;

        /**
         * Returns the alignment of the transition.
         */
        Alignment alignment() const;

        /**
         * Returns the direction of motion of the transition.
         */
        Direction direction() const;

        /**
         * Returns the angle of rotation of the transition.
         */
        int angle() const;

        /**
         * Returns the starting or ending scale (Only if type == 'Fly').
         */
        double scale() const;

        /**
         * Returns true if the area to be flown is rectangular and opaque (Only if type == 'Fly').
         */
        bool isRectangular() const;

        /**
         * Sets the @p type of the transition (@ref Type).
         */
        void setType( Type type );

        /**
         * Sets the @p duration in seconds for the transition.
         */
        void setDuration( int duration );

        /**
         * Sets the @p alignment of the transition (@ref Alignment).
         */
        void setAlignment( Alignment alignment );

        /**
         * Sets the @p direction of the transition (@see Direction).
         */
        void setDirection( Direction direction );

        /**
         * Sets the moving @p angle of the transition.
         */
        void setAngle( int angle );

        /**
         * Sets the starting or ending scale of the transition (Only if type == 'Fly').
         */
        void setScale( double scale );

        /**
         * Sets whether the area to be flown is rectangular and opaque (Only if type == 'Fly').
         */
        void setIsRectangular( bool rectangular );

    private:
        class Private;
        Private* const d;
};

}

#endif