]> Pileus Git - ~andy/gtk/blobdiff - gtk/gtkcellrenderer.h
Finish making the GtkSettings object identical on all backends so that it doesn't...
[~andy/gtk] / gtk / gtkcellrenderer.h
index e74be262a2c53b04d345052895d115991c18d47a..8ae77f677b235f78c05b33541690967f5150d661 100644 (file)
@@ -17,7 +17,7 @@
  * Boston, MA 02111-1307, USA.
  */
 
-#if defined(GTK_DISABLE_SINGLE_INCLUDES) && !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
 #error "Only <gtk/gtk.h> can be included directly."
 #endif
 
 
 G_BEGIN_DECLS
 
+
+/**
+ * GtkCellRendererState:
+ * @GTK_CELL_RENDERER_SELECTED: The cell is currently selected, and
+ *  probably has a selection colored background to render to.
+ * @GTK_CELL_RENDERER_PRELIT: The mouse is hovering over the cell.
+ * @GTK_CELL_RENDERER_INSENSITIVE: The cell is drawn in an insensitive manner
+ * @GTK_CELL_RENDERER_SORTED: The cell is in a sorted row
+ * @GTK_CELL_RENDERER_FOCUSED: The cell is in the focus row.
+ *
+ * Tells how a cell is to be rendererd.
+ */
 typedef enum
 {
   GTK_CELL_RENDERER_SELECTED    = 1 << 0,
@@ -38,6 +50,17 @@ typedef enum
   GTK_CELL_RENDERER_FOCUSED     = 1 << 4
 } GtkCellRendererState;
 
+/**
+ * GtkCellRendererMode:
+ * @GTK_CELL_RENDERER_MODE_INERT: The cell is just for display
+ *  and cannot be interacted with.  Note that this doesn't mean that eg. the
+ *  row being drawn can't be selected -- just that a particular element of
+ *  it cannot be individually modified.
+ * @GTK_CELL_RENDERER_MODE_ACTIVATABLE: The cell can be clicked.
+ * @GTK_CELL_RENDERER_MODE_EDITABLE: The cell can be edited or otherwise modified.
+ *
+ * Identifies how the user can interact with a particular cell.
+ */
 typedef enum
 {
   GTK_CELL_RENDERER_MODE_INERT,
@@ -52,64 +75,74 @@ typedef enum
 #define GTK_IS_CELL_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER))
 #define GTK_CELL_RENDERER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER, GtkCellRendererClass))
 
-typedef struct _GtkCellRenderer GtkCellRenderer;
-typedef struct _GtkCellRendererClass GtkCellRendererClass;
+typedef struct _GtkCellRenderer              GtkCellRenderer;
+typedef struct _GtkCellRendererPrivate       GtkCellRendererPrivate;
+typedef struct _GtkCellRendererClass         GtkCellRendererClass;
 
 struct _GtkCellRenderer
 {
-  GtkObject parent;
-
-  gfloat GSEAL (xalign);
-  gfloat GSEAL (yalign);
-
-  gint GSEAL (width);
-  gint GSEAL (height);
+  GInitiallyUnowned parent_instance;
 
-  guint16 GSEAL (xpad);
-  guint16 GSEAL (ypad);
-
-  guint GSEAL (mode) : 2;
-  guint GSEAL (visible) : 1;
-  guint GSEAL (is_expander) : 1;
-  guint GSEAL (is_expanded) : 1;
-  guint GSEAL (cell_background_set) : 1;
-  guint GSEAL (sensitive) : 1;
-  guint GSEAL (editing) : 1;
+  /*< private >*/
+  GtkCellRendererPrivate *priv;
 };
 
 struct _GtkCellRendererClass
 {
-  GtkObjectClass parent_class;
+  GInitiallyUnownedClass parent_class;
 
   /* vtable - not signals */
-  void             (* get_size)      (GtkCellRenderer      *cell,
-                                     GtkWidget            *widget,
-                                     GdkRectangle         *cell_area,
-                                     gint                 *x_offset,
-                                     gint                 *y_offset,
-                                     gint                 *width,
-                                     gint                 *height);
-  void             (* render)        (GtkCellRenderer      *cell,
-                                     GdkDrawable          *window,
-                                     GtkWidget            *widget,
-                                     GdkRectangle         *background_area,
-                                     GdkRectangle         *cell_area,
-                                     GdkRectangle         *expose_area,
-                                     GtkCellRendererState  flags);
-  gboolean         (* activate)      (GtkCellRenderer      *cell,
-                                     GdkEvent             *event,
-                                     GtkWidget            *widget,
-                                     const gchar          *path,
-                                     GdkRectangle         *background_area,
-                                     GdkRectangle         *cell_area,
-                                     GtkCellRendererState  flags);
-  GtkCellEditable *(* start_editing) (GtkCellRenderer      *cell,
-                                     GdkEvent             *event,
-                                     GtkWidget            *widget,
-                                     const gchar          *path,
-                                     GdkRectangle         *background_area,
-                                     GdkRectangle         *cell_area,
-                                     GtkCellRendererState  flags);
+  GtkSizeRequestMode (* get_request_mode)                (GtkCellRenderer      *cell);
+  void               (* get_preferred_width)             (GtkCellRenderer      *cell,
+                                                          GtkWidget            *widget,
+                                                          gint                 *minimum_size,
+                                                          gint                 *natural_size);
+  void               (* get_preferred_height_for_width)  (GtkCellRenderer      *cell,
+                                                          GtkWidget            *widget,
+                                                          gint                  width,
+                                                          gint                 *minimum_height,
+                                                          gint                 *natural_height);
+  void               (* get_preferred_height)            (GtkCellRenderer      *cell,
+                                                          GtkWidget            *widget,
+                                                          gint                 *minimum_size,
+                                                          gint                 *natural_size);
+  void               (* get_preferred_width_for_height)  (GtkCellRenderer      *cell,
+                                                          GtkWidget            *widget,
+                                                          gint                  height,
+                                                          gint                 *minimum_width,
+                                                          gint                 *natural_width);
+  void               (* get_aligned_area)                (GtkCellRenderer      *cell,
+                                                          GtkWidget            *widget,
+                                                         GtkCellRendererState  flags,
+                                                          const GdkRectangle   *cell_area,
+                                                          GdkRectangle         *aligned_area);
+  void               (* get_size)                        (GtkCellRenderer      *cell,
+                                                          GtkWidget            *widget,
+                                                          const GdkRectangle   *cell_area,
+                                                          gint                 *x_offset,
+                                                          gint                 *y_offset,
+                                                          gint                 *width,
+                                                          gint                 *height);
+  void               (* render)                          (GtkCellRenderer      *cell,
+                                                          cairo_t              *cr,
+                                                          GtkWidget            *widget,
+                                                          const GdkRectangle   *background_area,
+                                                          const GdkRectangle   *cell_area,
+                                                          GtkCellRendererState  flags);
+  gboolean           (* activate)                        (GtkCellRenderer      *cell,
+                                                          GdkEvent             *event,
+                                                          GtkWidget            *widget,
+                                                          const gchar          *path,
+                                                          const GdkRectangle   *background_area,
+                                                          const GdkRectangle   *cell_area,
+                                                          GtkCellRendererState  flags);
+  GtkCellEditable *  (* start_editing)                   (GtkCellRenderer      *cell,
+                                                          GdkEvent             *event,
+                                                          GtkWidget            *widget,
+                                                          const gchar          *path,
+                                                          const GdkRectangle   *background_area,
+                                                          const GdkRectangle   *cell_area,
+                                                          GtkCellRendererState  flags);
 
   /* Signals */
   void (* editing_canceled) (GtkCellRenderer *cell);
@@ -120,10 +153,42 @@ struct _GtkCellRendererClass
   /* Padding for future expansion */
   void (*_gtk_reserved1) (void);
   void (*_gtk_reserved2) (void);
+  void (*_gtk_reserved3) (void);
+  void (*_gtk_reserved4) (void);
 };
 
-GType            gtk_cell_renderer_get_type       (void) G_GNUC_CONST;
+GType              gtk_cell_renderer_get_type       (void) G_GNUC_CONST;
+
+GtkSizeRequestMode gtk_cell_renderer_get_request_mode               (GtkCellRenderer    *cell);
+void               gtk_cell_renderer_get_preferred_width            (GtkCellRenderer    *cell,
+                                                                     GtkWidget          *widget,
+                                                                     gint               *minimum_size,
+                                                                     gint               *natural_size);
+void               gtk_cell_renderer_get_preferred_height_for_width (GtkCellRenderer    *cell,
+                                                                     GtkWidget          *widget,
+                                                                     gint                width,
+                                                                     gint               *minimum_height,
+                                                                     gint               *natural_height);
+void               gtk_cell_renderer_get_preferred_height           (GtkCellRenderer    *cell,
+                                                                     GtkWidget          *widget,
+                                                                     gint               *minimum_size,
+                                                                     gint               *natural_size);
+void               gtk_cell_renderer_get_preferred_width_for_height (GtkCellRenderer    *cell,
+                                                                     GtkWidget          *widget,
+                                                                     gint                height,
+                                                                     gint               *minimum_width,
+                                                                     gint               *natural_width);
+void               gtk_cell_renderer_get_preferred_size             (GtkCellRenderer    *cell,
+                                                                     GtkWidget          *widget,
+                                                                     GtkRequisition     *minimum_size,
+                                                                     GtkRequisition     *natural_size);
+void               gtk_cell_renderer_get_aligned_area               (GtkCellRenderer    *cell,
+                                                                    GtkWidget          *widget,
+                                                                    GtkCellRendererState flags,
+                                                                    const GdkRectangle *cell_area,
+                                                                    GdkRectangle       *aligned_area);
 
+#ifndef GTK_DISABLE_DEPRECATED
 void             gtk_cell_renderer_get_size       (GtkCellRenderer      *cell,
                                                   GtkWidget            *widget,
                                                   const GdkRectangle   *cell_area,
@@ -131,12 +196,12 @@ void             gtk_cell_renderer_get_size       (GtkCellRenderer      *cell,
                                                   gint                 *y_offset,
                                                   gint                 *width,
                                                   gint                 *height);
+#endif
 void             gtk_cell_renderer_render         (GtkCellRenderer      *cell,
-                                                  GdkWindow            *window,
+                                                   cairo_t              *cr,
                                                   GtkWidget            *widget,
                                                   const GdkRectangle   *background_area,
                                                   const GdkRectangle   *cell_area,
-                                                  const GdkRectangle   *expose_area,
                                                   GtkCellRendererState  flags);
 gboolean         gtk_cell_renderer_activate       (GtkCellRenderer      *cell,
                                                   GdkEvent             *event,
@@ -182,11 +247,25 @@ void             gtk_cell_renderer_set_sensitive  (GtkCellRenderer      *cell,
                                                    gboolean              sensitive);
 gboolean         gtk_cell_renderer_get_sensitive  (GtkCellRenderer      *cell);
 
+gboolean         gtk_cell_renderer_is_activatable (GtkCellRenderer      *cell);
+
 /* For use by cell renderer implementations only */
 void             gtk_cell_renderer_stop_editing   (GtkCellRenderer      *cell,
                                                    gboolean              canceled);
 
 
+void            _gtk_cell_renderer_calc_offset    (GtkCellRenderer      *cell,
+                                                   const GdkRectangle   *cell_area,
+                                                   GtkTextDirection      direction,
+                                                   gint                  width,
+                                                   gint                  height,
+                                                   gint                 *x_offset,
+                                                   gint                 *y_offset);
+
+GtkStateFlags   gtk_cell_renderer_get_state       (GtkCellRenderer      *cell,
+                                                   GtkWidget            *widget,
+                                                   GtkCellRendererState  cell_state);
+
 G_END_DECLS
 
 #endif /* __GTK_CELL_RENDERER_H__ */