gtkD/src/gtk/CellRendererPixbuf.d

   1 /*
   2  * This file is part of gtkD.
   3  *
   4  * gtkD is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU Lesser General Public License as published by
   6  * the Free Software Foundation; either version 2.1 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * gtkD is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public License
  15  * along with gtkD; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 // generated automatically - do not change
  20 // find conversion definition on APILookup.txt
  21 // implement new conversion functionalities on the wrap.utils pakage
  22
  23 /*
  24  * Conversion parameters:
  25  * inFile  = GtkCellRendererPixbuf.html
  26  * outPack = gtk
  27  * outFile = CellRendererPixbuf
  28  * strct   = GtkCellRenderer
  29  * realStrct=GtkCellRendererPixbuf
  30  * ctorStrct=
  31  * clss    = CellRendererPixbuf
  32  * interf  =
  33  * class Code: No
  34  * interface Code: No
  35  * template for:
  36  * extend  =
  37  * implements:
  38  * prefixes:
  39  *      - gtk_cell_renderer_pixbuf_
  40  *      - gtk_
  41  * omit structs:
  42  * omit prefixes:
  43  * omit code:
  44  * imports:
  45  *      - gtk.CellRenderer
  46  * structWrap:
  47  *      - GtkCellRenderer* -> CellRenderer
  48  * module aliases:
  49  * local aliases:
  50  */
  51
  52 module gtk.CellRendererPixbuf;
  53
  54 version(noAssert)
  55 {
  56         version(Tango)
  57         {
  58                 import tango.io.Stdout; // use the tango loging?
  59         }
  60 }
  61
  62 private import gtkc.gtktypes;
  63
  64 private import gtkc.gtk;
  65
  66
  67 private import gtk.CellRenderer;
  68
  69
  70
  71
  72 /**
  73  * Description
  74  * A GtkCellRendererPixbuf can be used to render an image in a cell. It allows to render
  75  * either a given GdkPixbuf (set via the
  76  * pixbuf property) or a stock icon
  77  * (set via the stock-id property).
  78  * To support the tree view, GtkCellRendererPixbuf also supports rendering two alternative
  79  * pixbufs, when the is-expander property
  80  * is TRUE. If the is-expanded property
  81  * is TRUE and the
  82  * pixbuf-expander-open
  83  * property is set to a pixbuf, it renders that pixbuf, if the
  84  * is-expanded property is FALSE and
  85  * the
  86  * pixbuf-expander-closed
  87  * property is set to a pixbuf, it renders that one.
  88  */
  89 private import gtk.CellRenderer;
  90 public class CellRendererPixbuf : CellRenderer
  91 {
  92
  93         /** the main Gtk struct */
  94         protected GtkCellRendererPixbuf* gtkCellRendererPixbuf;
  95
  96
  97         public GtkCellRendererPixbuf* getCellRendererPixbufStruct()
  98         {
  99                 return gtkCellRendererPixbuf;
 100         }
 101
 102
 103         /** the main Gtk struct as a void* */
 104         protected void* getStruct()
 105         {
 106                 return cast(void*)gtkCellRendererPixbuf;
 107         }
 108
 109         /**
 110          * Sets our main struct and passes it to the parent class
 111          */
 112         public this (GtkCellRendererPixbuf* gtkCellRendererPixbuf)
 113         {
 114                 version(noAssert)
 115                 {
 116                         if ( gtkCellRendererPixbuf is null )
 117                         {
 118                                 int zero = 0;
 119                                 version(Tango)
 120                                 {
 121                                         Stdout("struct gtkCellRendererPixbuf is null on constructor").newline;
 122                                 }
 123                                 else
 124                                 {
 125                                         printf("struct gtkCellRendererPixbuf is null on constructor");
 126                                 }
 127                                 zero = zero / zero;
 128                         }
 129                 }
 130                 else
 131                 {
 132                         assert(gtkCellRendererPixbuf !is null, "struct gtkCellRendererPixbuf is null on constructor");
 133                 }
 134                 super(cast(GtkCellRenderer*)gtkCellRendererPixbuf);
 135                 this.gtkCellRendererPixbuf = gtkCellRendererPixbuf;
 136         }
 137
 138         /**
 139          */
 140
 141
 142         /**
 143          * Creates a new GtkCellRendererPixbuf. Adjust rendering
 144          * parameters using object properties. Object properties can be set
 145          * globally (with g_object_set()). Also, with GtkTreeViewColumn, you
 146          * can bind a property to a value in a GtkTreeModel. For example, you
 147          * can bind the "pixbuf" property on the cell renderer to a pixbuf value
 148          * in the model, thus rendering a different image in each row of the
 149          * GtkTreeView.
 150          * Returns:
 151          *  the new cell renderer
 152          * Property Details
 153          * The "follow-state" property
 154          *  "follow-state" gboolean : Read / Write
 155          * Specifies whether the rendered pixbuf should be colorized
 156          * according to the GtkCellRendererState.
 157          * Default value: FALSE
 158          * Since 2.8
 159          */
 160         public this ()
 161         {
 162                 // GtkCellRenderer* gtk_cell_renderer_pixbuf_new (void);
 163                 this(cast(GtkCellRendererPixbuf*)gtk_cell_renderer_pixbuf_new() );
 164         }
 165
 166
 167
 168
 169
 170
 171
 172 }