This file is indexed.

/usr/include/clutter-1.0/clutter/clutter-timeline.h is in libclutter-1.0-dev 1.16.4-0ubuntu2.

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
/*
 * Clutter.
 *
 * An OpenGL based 'interactive canvas' library.
 *
 * Authored By Matthew Allum  <mallum@openedhand.com>
 *
 * Copyright (C) 2006 OpenedHand
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
 */

#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only <clutter/clutter.h> can be included directly."
#endif

#ifndef __CLUTTER_TIMELINE_H__
#define __CLUTTER_TIMELINE_H__

#include <clutter/clutter-types.h>

G_BEGIN_DECLS

#define CLUTTER_TYPE_TIMELINE                   (clutter_timeline_get_type ())
#define CLUTTER_TIMELINE(obj)                   (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_TIMELINE, ClutterTimeline))
#define CLUTTER_TIMELINE_CLASS(klass)           (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_TIMELINE, ClutterTimelineClass))
#define CLUTTER_IS_TIMELINE(obj)                (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_TIMELINE))
#define CLUTTER_IS_TIMELINE_CLASS(klass)        (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_TIMELINE))
#define CLUTTER_TIMELINE_GET_CLASS(obj)         (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_TIMELINE, ClutterTimelineClass))

typedef struct _ClutterTimelineClass   ClutterTimelineClass; 
typedef struct _ClutterTimelinePrivate ClutterTimelinePrivate;

/**
 * ClutterTimelineProgressFunc:
 * @timeline: a #ClutterTimeline
 * @elapsed: the elapsed time, in milliseconds
 * @total: the total duration of the timeline, in milliseconds,
 * @user_data: data passed to the function
 *
 * A function for defining a custom progress.
 *
 * Return value: the progress, as a floating point value between -1.0 and 2.0.
 *
 * Since: 1.10
 */
typedef gdouble (* ClutterTimelineProgressFunc) (ClutterTimeline *timeline,
                                                 gdouble          elapsed,
                                                 gdouble          total,
                                                 gpointer         user_data);

/**
 * ClutterTimeline:
 *
 * The #ClutterTimeline structure contains only private data
 * and should be accessed using the provided API
 *
 * Since: 0.2
 */
struct _ClutterTimeline
{
  /*< private >*/
  GObject parent_instance;

  ClutterTimelinePrivate *priv;
};

/**
 * ClutterTimelineClass:
 * @started: class handler for the #ClutterTimeline::started signal
 * @completed: class handler for the #ClutterTimeline::completed signal
 * @paused: class handler for the #ClutterTimeline::paused signal
 * @new_frame: class handler for the #ClutterTimeline::new-frame signal
 * @marker_reached: class handler for the #ClutterTimeline::marker-reached signal
 * @stopped: class handler for the #ClutterTimeline::stopped signal
 *
 * The #ClutterTimelineClass structure contains only private data
 *
 * Since: 0.2
 */
struct _ClutterTimelineClass
{
  /*< private >*/
  GObjectClass parent_class;
  
  /*< public >*/
  void (*started)        (ClutterTimeline *timeline);
  void (*completed)      (ClutterTimeline *timeline);
  void (*paused)         (ClutterTimeline *timeline);
  
  void (*new_frame)      (ClutterTimeline *timeline,
		          gint             msecs);

  void (*marker_reached) (ClutterTimeline *timeline,
                          const gchar     *marker_name,
                          gint             msecs);
  void (*stopped)        (ClutterTimeline *timeline,
                          gboolean         is_finished);

  /*< private >*/
  void (*_clutter_timeline_1) (void);
  void (*_clutter_timeline_2) (void);
  void (*_clutter_timeline_3) (void);
  void (*_clutter_timeline_4) (void);
};

GType clutter_timeline_get_type (void) G_GNUC_CONST;

ClutterTimeline *               clutter_timeline_new                            (guint                     msecs);

guint                           clutter_timeline_get_duration                   (ClutterTimeline          *timeline);
void                            clutter_timeline_set_duration                   (ClutterTimeline          *timeline,
                                                                                 guint                     msecs);
ClutterTimelineDirection        clutter_timeline_get_direction                  (ClutterTimeline          *timeline);
void                            clutter_timeline_set_direction                  (ClutterTimeline          *timeline,
                                                                                 ClutterTimelineDirection  direction);
void                            clutter_timeline_start                          (ClutterTimeline          *timeline);
void                            clutter_timeline_pause                          (ClutterTimeline          *timeline);
void                            clutter_timeline_stop                           (ClutterTimeline          *timeline);
void                            clutter_timeline_set_auto_reverse               (ClutterTimeline          *timeline,
                                                                                 gboolean                  reverse);
gboolean                        clutter_timeline_get_auto_reverse               (ClutterTimeline          *timeline);
CLUTTER_AVAILABLE_IN_1_10
void                            clutter_timeline_set_repeat_count               (ClutterTimeline          *timeline,
                                                                                 gint                      count);
CLUTTER_AVAILABLE_IN_1_10
gint                            clutter_timeline_get_repeat_count               (ClutterTimeline          *timeline);
void                            clutter_timeline_rewind                         (ClutterTimeline          *timeline);
void                            clutter_timeline_skip                           (ClutterTimeline          *timeline,
                                                                                 guint                     msecs);
void                            clutter_timeline_advance                        (ClutterTimeline          *timeline,
                                                                                 guint                     msecs);
guint                           clutter_timeline_get_elapsed_time               (ClutterTimeline          *timeline);
gdouble                         clutter_timeline_get_progress                   (ClutterTimeline          *timeline);
gboolean                        clutter_timeline_is_playing                     (ClutterTimeline          *timeline);
void                            clutter_timeline_set_delay                      (ClutterTimeline          *timeline,
                                                                                 guint                     msecs);
guint                           clutter_timeline_get_delay                      (ClutterTimeline          *timeline);
guint                           clutter_timeline_get_delta                      (ClutterTimeline          *timeline);
CLUTTER_AVAILABLE_IN_1_14
void                            clutter_timeline_add_marker                     (ClutterTimeline          *timeline,
                                                                                 const gchar              *marker_name,
                                                                                 gdouble                   progress);
void                            clutter_timeline_add_marker_at_time             (ClutterTimeline          *timeline,
                                                                                 const gchar              *marker_name,
                                                                                 guint                     msecs);
void                            clutter_timeline_remove_marker                  (ClutterTimeline          *timeline,
                                                                                 const gchar              *marker_name);
gchar **                        clutter_timeline_list_markers                   (ClutterTimeline          *timeline,
                                                                                 gint                      msecs,
                                                                                 gsize                    *n_markers) G_GNUC_MALLOC;
gboolean                        clutter_timeline_has_marker                     (ClutterTimeline          *timeline,
                                                                                 const gchar              *marker_name);
void                            clutter_timeline_advance_to_marker              (ClutterTimeline          *timeline,
                                                                                 const gchar              *marker_name);
CLUTTER_AVAILABLE_IN_1_10
void                            clutter_timeline_set_progress_func              (ClutterTimeline          *timeline,
                                                                                 ClutterTimelineProgressFunc func,
                                                                                 gpointer                  data,
                                                                                 GDestroyNotify            notify);
CLUTTER_AVAILABLE_IN_1_10
void                            clutter_timeline_set_progress_mode              (ClutterTimeline          *timeline,
                                                                                 ClutterAnimationMode      mode);
CLUTTER_AVAILABLE_IN_1_10
ClutterAnimationMode            clutter_timeline_get_progress_mode              (ClutterTimeline          *timeline);
CLUTTER_AVAILABLE_IN_1_12
void                            clutter_timeline_set_step_progress              (ClutterTimeline          *timeline,
                                                                                 gint                      n_steps,
                                                                                 ClutterStepMode           step_mode);
CLUTTER_AVAILABLE_IN_1_12
gboolean                        clutter_timeline_get_step_progress              (ClutterTimeline          *timeline,
                                                                                 gint                     *n_steps,
                                                                                 ClutterStepMode          *step_mode);
CLUTTER_AVAILABLE_IN_1_12
void                            clutter_timeline_set_cubic_bezier_progress      (ClutterTimeline          *timeline,
                                                                                 const ClutterPoint       *c_1,
                                                                                 const ClutterPoint       *c_2);
CLUTTER_AVAILABLE_IN_1_12
gboolean                        clutter_timeline_get_cubic_bezier_progress      (ClutterTimeline          *timeline,
                                                                                 ClutterPoint             *c_1,
                                                                                 ClutterPoint             *c_2);

CLUTTER_AVAILABLE_IN_1_10
gint64                          clutter_timeline_get_duration_hint              (ClutterTimeline          *timeline);
CLUTTER_AVAILABLE_IN_1_10
gint                            clutter_timeline_get_current_repeat             (ClutterTimeline          *timeline);

G_END_DECLS

#endif /* _CLUTTER_TIMELINE_H__ */