This file is indexed.

/usr/include/hippo-canvas-1/hippo/hippo-canvas-item.h is in libhippocanvas-dev 0.3.1-1.1.

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
/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil; -*- */
#ifndef __HIPPO_CANVAS_ITEM_H__
#define __HIPPO_CANVAS_ITEM_H__

#include <cairo.h>
#include <gdk/gdk.h>
#include <hippo/hippo-event.h>
#include <hippo/hippo-graphics.h>
#include <hippo/hippo-canvas-context.h>

G_BEGIN_DECLS

typedef enum {
    HIPPO_CANVAS_POINTER_UNSET,
    HIPPO_CANVAS_POINTER_DEFAULT,
    HIPPO_CANVAS_POINTER_HAND
} HippoCanvasPointer;

/* How an item deals with extra allocation in a single (x or y) dimension */
typedef enum {
    HIPPO_ALIGNMENT_FILL,
    HIPPO_ALIGNMENT_START, /* left or top */
    HIPPO_ALIGNMENT_CENTER,
    HIPPO_ALIGNMENT_END    /* right or bottom */
} HippoItemAlignment;

#define HIPPO_TYPE_CANVAS_ITEM              (hippo_canvas_item_get_type ())
#define HIPPO_CANVAS_ITEM(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), HIPPO_TYPE_CANVAS_ITEM, HippoCanvasItem))
#define HIPPO_IS_CANVAS_ITEM(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), HIPPO_TYPE_CANVAS_ITEM))
#define HIPPO_CANVAS_ITEM_GET_IFACE(obj)    (G_TYPE_INSTANCE_GET_INTERFACE ((obj), HIPPO_TYPE_CANVAS_ITEM, HippoCanvasItemIface))

struct _HippoCanvasItemIface {
    GTypeInterface base_iface;

    HippoCanvasContext*    (* get_context)          (HippoCanvasItem *canvas_item);
    void                   (* set_context)          (HippoCanvasItem      *canvas_item,
                                                     HippoCanvasContext   *context);
    void                   (* set_parent)           (HippoCanvasItem      *canvas_item,
                                                     HippoCanvasContainer *container);
    HippoCanvasContainer*  (* get_parent)           (HippoCanvasItem *canvas_item);
    void                   (* paint)                (HippoCanvasItem *canvas_item,
                                                     cairo_t         *cr,
                                                     GdkRegion       *damaged_region);
    void                   (* get_width_request)    (HippoCanvasItem *canvas_item,
                                                     int             *min_width_p,
                                                     int             *natural_width_p);
    void                   (* get_height_request)   (HippoCanvasItem *canvas_item,
                                                     int              for_width,
                                                     int             *min_height_p,
                                                     int             *natural_height_p);
    
    /* The origin changed flag indicates that the position of the item with respect to the
     * canvas root changed. The item must then call allocate on it's children passing
     * TRUE for origin_changed as well. */
    void                   (* allocate)             (HippoCanvasItem *canvas_item,
                                                     int              width,
                                                     int              height,
                                                     gboolean         origin_changed);
    void                   (* get_allocation)       (HippoCanvasItem *canvas_item,
                                                     int             *width_p,
                                                     int             *height_p);
    gboolean               (* button_press_event)   (HippoCanvasItem *canvas_item,
                                                     HippoEvent      *event);
    gboolean               (* button_release_event) (HippoCanvasItem *canvas_item,
                                                     HippoEvent      *event);
    gboolean               (* motion_notify_event)  (HippoCanvasItem *canvas_item,
                                                     HippoEvent      *event);
    gboolean               (* key_press_event)      (HippoCanvasItem *canvas_item,
                                                     HippoEvent      *event);
    void                   (* activated)            (HippoCanvasItem *canvas_item);
    void                   (* request_changed)      (HippoCanvasItem *canvas_item);
    void                   (* paint_needed)         (HippoCanvasItem *canvas_item,
                                                     const HippoRectangle *damage_box);
    gboolean               (* get_needs_request)    (HippoCanvasItem *canvas_item);
    char*                  (* get_tooltip)          (HippoCanvasItem *canvas_item,
                                                     int              x,
                                                     int              y,
                                                     HippoRectangle  *for_area);
    void                   (* tooltip_changed)      (HippoCanvasItem *canvas_item);
    HippoCanvasPointer     (* get_pointer)          (HippoCanvasItem *canvas_item,
                                                     int              x,
                                                     int              y);
    gboolean               (* scroll_event)         (HippoCanvasItem *canvas_item,
                                                     HippoEvent      *event);    
};

GType                 hippo_canvas_item_get_type           (void) G_GNUC_CONST;
void                  hippo_canvas_item_destroy            (HippoCanvasItem    *canvas_item);
HippoCanvasContext*   hippo_canvas_item_get_context        (HippoCanvasItem    *canvas_item);
void                  hippo_canvas_item_set_context        (HippoCanvasItem    *canvas_item,
                                                            HippoCanvasContext *context);
void                  hippo_canvas_item_set_parent         (HippoCanvasItem      *canvas_item,
                                                            HippoCanvasContainer *container);
HippoCanvasContainer* hippo_canvas_item_get_parent         (HippoCanvasItem      *canvas_item);
void                  hippo_canvas_item_get_width_request  (HippoCanvasItem    *canvas_item,
                                                            int                *min_width_p,
                                                            int                *natural_width_p);
void                  hippo_canvas_item_get_height_request (HippoCanvasItem    *canvas_item,
                                                            int                 for_width,
                                                            int                *min_height_p,
                                                            int                *natural_height_p);
void                  hippo_canvas_item_allocate           (HippoCanvasItem    *canvas_item,
                                                            int                 width,
                                                            int                 height,
                                                            gboolean            origin_changed);
void                  hippo_canvas_item_get_allocation     (HippoCanvasItem    *canvas_item,
                                                            int                *width_p,
                                                            int                *height_p);
gboolean              hippo_canvas_item_get_needs_request  (HippoCanvasItem    *canvas_item);
char*                 hippo_canvas_item_get_tooltip        (HippoCanvasItem    *canvas_item,
                                                            int                 x,
                                                            int                 y,
                                                            HippoRectangle     *for_area);
HippoCanvasPointer    hippo_canvas_item_get_pointer        (HippoCanvasItem    *canvas_item,
                                                            int                 x,
                                                            int                 y);
gboolean              hippo_canvas_item_get_visible        (HippoCanvasItem    *canvas_item);
void                  hippo_canvas_item_set_visible        (HippoCanvasItem    *canvas_item,
                                                            gboolean            visible); 

void     hippo_canvas_item_emit_destroy              (HippoCanvasItem *canvas_item);
gboolean hippo_canvas_item_emit_button_press_event   (HippoCanvasItem *canvas_item,
                                                      int              x,
                                                      int              y,
                                                      int              button,
                                                      int              x11_x_root,
                                                      int              x11_y_root,
                                                      guint32          x11_time,
                                                      int              count);
gboolean hippo_canvas_item_emit_button_release_event (HippoCanvasItem *canvas_item,
                                                      int              x,
                                                      int              y,
                                                      int              button,
                                                      int              x11_x_root,
                                                      int              x11_y_root,
                                                      guint32          x11_time);
gboolean hippo_canvas_item_emit_motion_notify_event  (HippoCanvasItem  *canvas_item,
                                                      int               x,
                                                      int               y,
                                                      HippoMotionDetail detail);
gboolean hippo_canvas_item_emit_key_press_event      (HippoCanvasItem  *canvas_item,
                                                      HippoKey          key,
                                                      gunichar          character,
                                                      guint             modifiers);
gboolean hippo_canvas_item_emit_scroll_event         (HippoCanvasItem     *canvas_item,
                                                      int                  x,
                                                      int                  y,
                                                      HippoScrollDirection direction);
void     hippo_canvas_item_emit_activated            (HippoCanvasItem *canvas_item);
void     hippo_canvas_item_emit_paint_needed         (HippoCanvasItem *canvas_item,
                                                      int              x,
                                                      int              y,
                                                      int              width,
                                                      int              height);
void     hippo_canvas_item_emit_tooltip_changed      (HippoCanvasItem *canvas_item);
void     hippo_canvas_item_emit_request_changed      (HippoCanvasItem *canvas_item);
gboolean hippo_canvas_item_process_event             (HippoCanvasItem *canvas_item,
                                                      HippoEvent      *event,
                                                      int              allocation_x,
                                                      int              allocation_y);
void     hippo_canvas_item_process_paint             (HippoCanvasItem *canvas_item,
                                                      cairo_t         *cr,
                                                      GdkRegion       *damaged_region,
                                                      int              allocation_x,
                                                      int              allocation_y);

G_END_DECLS

#endif /* __HIPPO_CANVAS_ITEM_H__ */