src/gtk/CellRendererToggle.d

   1 /*
   2  * This file is part of duit.
   3  *
   4  * duit 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  * duit 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 duit; 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  = GtkCellRendererToggle.html
  26  * outPack = gtk
  27  * outFile = CellRendererToggle
  28  * strct   = GtkCellRenderer
  29  * realStrct=GtkCellRendererToggle
  30  * ctorStrct=
  31  * clss    = CellRendererToggle
  32  * interf  =
  33  * class Code: No
  34  * interface Code: No
  35  * template for:
  36  * extend  =
  37  * implements:
  38  * prefixes:
  39  *      - gtk_cell_renderer_toggle_
  40  *      - gtk_
  41  * omit structs:
  42  * omit prefixes:
  43  * omit code:
  44  * imports:
  45  *      - glib.Str
  46  *      - gtk.CellRenderer
  47  * structWrap:
  48  *      - GtkCellRenderer* -> CellRenderer
  49  * local aliases:
  50  */
  51
  52 module gtk.CellRendererToggle;
  53
  54 private import gtk.gtktypes;
  55
  56 private import lib.gtk;
  57
  58 private import glib.Str;
  59 private import gtk.CellRenderer;
  60
  61 /**
  62  * Description
  63  * GtkCellRendererToggle renders a toggle button in a cell. The
  64  * button is drawn as a radio- or checkbutton, depending on the
  65  * radio
  66  * property. When activated, it emits the toggled signal.
  67  */
  68 private import gtk.CellRenderer;
  69 public class CellRendererToggle : CellRenderer
  70 {
  71
  72         /** the main Gtk struct */
  73         protected GtkCellRendererToggle* gtkCellRendererToggle;
  74
  75
  76         public GtkCellRendererToggle* getCellRendererToggleStruct()
  77         {
  78                 return gtkCellRendererToggle;
  79         }
  80
  81
  82         /** the main Gtk struct as a void* */
  83         protected void* getStruct()
  84         {
  85                 return cast(void*)gtkCellRendererToggle;
  86         }
  87
  88         /**
  89          * Sets our main struct and passes it to the parent class
  90          */
  91         public this (GtkCellRendererToggle* gtkCellRendererToggle)
  92         {
  93                 super(cast(GtkCellRenderer*)gtkCellRendererToggle);
  94                 this.gtkCellRendererToggle = gtkCellRendererToggle;
  95         }
  96
  97         /**
  98          */
  99
 100         // imports for the signal processing
 101         private import gobject.Signals;
 102         private import gdk.gdktypes;
 103         int[char[]] connectedSignals;
 104
 105         void delegate(char[], CellRendererToggle)[] onToggledListeners;
 106         void addOnToggled(void delegate(char[], CellRendererToggle) dlg)
 107         {
 108                 if ( !("toggled" in connectedSignals) )
 109                 {
 110                         Signals.connectData(
 111                         getStruct(),
 112                         "toggled",
 113                         cast(GCallback)&callBackToggled,
 114                         this,
 115                         null,
 116                         cast(ConnectFlags)0);
 117                         connectedSignals["toggled"] = 1;
 118                 }
 119                 onToggledListeners ~= dlg;
 120         }
 121         extern(C) static void callBackToggled(GtkCellRendererToggle* cellRendererStruct, gchar* path, CellRendererToggle cellRendererToggle)
 122         {
 123                 bit consumed = false;
 124
 125                 foreach ( void delegate(char[], CellRendererToggle) dlg ; cellRendererToggle.onToggledListeners )
 126                 {
 127                         dlg(Str.toString(path), cellRendererToggle);
 128                 }
 129
 130                 return consumed;
 131         }
 132
 133
 134
 135         /**
 136          * Creates a new GtkCellRendererToggle. Adjust rendering
 137          * parameters using object properties. Object properties can be set
 138          * globally (with g_object_set()). Also, with GtkTreeViewColumn, you
 139          * can bind a property to a value in a GtkTreeModel. For example, you
 140          * can bind the "active" property on the cell renderer to a boolean value
 141          * in the model, thus causing the check button to reflect the state of
 142          * the model.
 143          * Returns:
 144          *  the new cell renderer
 145          */
 146         public this ()
 147         {
 148                 // GtkCellRenderer* gtk_cell_renderer_toggle_new  (void);
 149                 this(cast(GtkCellRendererToggle*)gtk_cell_renderer_toggle_new() );
 150         }
 151
 152         /**
 153          * Returns whether we're rendering radio toggles rather than checkboxes.
 154          * toggle:
 155          *  a GtkCellRendererToggle
 156          * Returns:
 157          *  TRUE if we're rendering radio toggles rather than checkboxes
 158          */
 159         public static int getRadio(GtkCellRendererToggle* toggle)
 160         {
 161                 // gboolean gtk_cell_renderer_toggle_get_radio  (GtkCellRendererToggle *toggle);
 162                 return gtk_cell_renderer_toggle_get_radio(toggle);
 163         }
 164
 165         /**
 166          * If radio is TRUE, the cell renderer renders a radio toggle
 167          * (i.e. a toggle in a group of mutually-exclusive toggles).
 168          * If FALSE, it renders a check toggle (a standalone boolean option).
 169          * This can be set globally for the cell renderer, or changed just
 170          * before rendering each cell in the model (for GtkTreeView, you set
 171          * up a per-row setting using GtkTreeViewColumn to associate model
 172          * columns with cell renderer properties).
 173          * toggle:
 174          *  a GtkCellRendererToggle
 175          * radio:
 176          *  TRUE to make the toggle look like a radio button
 177          */
 178         public static void setRadio(GtkCellRendererToggle* toggle, int radio)
 179         {
 180                 // void gtk_cell_renderer_toggle_set_radio  (GtkCellRendererToggle *toggle,  gboolean radio);
 181                 gtk_cell_renderer_toggle_set_radio(toggle, radio);
 182         }
 183
 184         /**
 185          * Returns whether the cell renderer is active. See
 186          * gtk_cell_renderer_toggle_set_active().
 187          * toggle:
 188          *  a GtkCellRendererToggle
 189          * Returns:
 190          *  TRUE if the cell renderer is active.
 191          */
 192         public static int getActive(GtkCellRendererToggle* toggle)
 193         {
 194                 // gboolean gtk_cell_renderer_toggle_get_active  (GtkCellRendererToggle *toggle);
 195                 return gtk_cell_renderer_toggle_get_active(toggle);
 196         }
 197
 198         /**
 199          * Activates or deactivates a cell renderer.
 200          * toggle:
 201          *  a GtkCellRendererToggle.
 202          * setting:
 203          *  the value to set.
 204          * Property Details
 205          * The "activatable" property
 206          *  "activatable" gboolean : Read / Write
 207          * The toggle button can be activated.
 208          * Default value: TRUE
 209          */
 210         public static void setActive(GtkCellRendererToggle* toggle, int setting)
 211         {
 212                 // void gtk_cell_renderer_toggle_set_active  (GtkCellRendererToggle *toggle,  gboolean setting);
 213                 gtk_cell_renderer_toggle_set_active(toggle, setting);
 214         }
 215
 216
 217
 218
 219 }