src/gtk/CellEditable.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  = GtkCellEditable.html
  26  * outPack = gtk
  27  * outFile = CellEditable
  28  * strct   = GtkCellEditable
  29  * realStrct=
  30  * ctorStrct=
  31  * clss    = CellEditable
  32  * interf  =
  33  * class Code: No
  34  * interface Code: No
  35  * template for:
  36  * extend  =
  37  * implements:
  38  * prefixes:
  39  *      - gtk_cell_editable_
  40  *      - gtk_
  41  * omit structs:
  42  * omit prefixes:
  43  * omit code:
  44  * imports:
  45  *      - gdk.Event
  46  * structWrap:
  47  *      - GdkEvent* -> Event
  48  * local aliases:
  49  */
  50
  51 module gtk.CellEditable;
  52
  53 private import gtk.gtktypes;
  54
  55 private import lib.gtk;
  56
  57 private import gdk.Event;
  58
  59 /**
  60  * Description
  61  * The GtkCellEditable interface must be implemented for widgets
  62  * to be usable when editing the contents of a GtkTreeView cell.
  63  */
  64 public class CellEditable
  65 {
  66
  67         /** the main Gtk struct */
  68         protected GtkCellEditable* gtkCellEditable;
  69
  70
  71         public GtkCellEditable* getCellEditableStruct()
  72         {
  73                 return gtkCellEditable;
  74         }
  75
  76
  77         /** the main Gtk struct as a void* */
  78         protected void* getStruct()
  79         {
  80                 return cast(void*)gtkCellEditable;
  81         }
  82
  83         /**
  84          * Sets our main struct and passes it to the parent class
  85          */
  86         public this (GtkCellEditable* gtkCellEditable)
  87         {
  88                 this.gtkCellEditable = gtkCellEditable;
  89         }
  90
  91         /**
  92          */
  93
  94         // imports for the signal processing
  95         private import gobject.Signals;
  96         private import gdk.gdktypes;
  97         int[char[]] connectedSignals;
  98
  99         void delegate(CellEditable)[] onEditingDoneListeners;
 100         void addOnEditingDone(void delegate(CellEditable) dlg)
 101         {
 102                 if ( !("editing-done" in connectedSignals) )
 103                 {
 104                         Signals.connectData(
 105                         getStruct(),
 106                         "editing-done",
 107                         cast(GCallback)&callBackEditingDone,
 108                         this,
 109                         null,
 110                         cast(ConnectFlags)0);
 111                         connectedSignals["editing-done"] = 1;
 112                 }
 113                 onEditingDoneListeners ~= dlg;
 114         }
 115         extern(C) static void callBackEditingDone(GtkCellEditable* celleditableStruct, CellEditable cellEditable)
 116         {
 117                 bit consumed = false;
 118
 119                 foreach ( void delegate(CellEditable) dlg ; cellEditable.onEditingDoneListeners )
 120                 {
 121                         dlg(cellEditable);
 122                 }
 123
 124                 return consumed;
 125         }
 126
 127         void delegate(CellEditable)[] onRemoveWidgetListeners;
 128         void addOnRemoveWidget(void delegate(CellEditable) dlg)
 129         {
 130                 if ( !("remove-widget" in connectedSignals) )
 131                 {
 132                         Signals.connectData(
 133                         getStruct(),
 134                         "remove-widget",
 135                         cast(GCallback)&callBackRemoveWidget,
 136                         this,
 137                         null,
 138                         cast(ConnectFlags)0);
 139                         connectedSignals["remove-widget"] = 1;
 140                 }
 141                 onRemoveWidgetListeners ~= dlg;
 142         }
 143         extern(C) static void callBackRemoveWidget(GtkCellEditable* celleditableStruct, CellEditable cellEditable)
 144         {
 145                 bit consumed = false;
 146
 147                 foreach ( void delegate(CellEditable) dlg ; cellEditable.onRemoveWidgetListeners )
 148                 {
 149                         dlg(cellEditable);
 150                 }
 151
 152                 return consumed;
 153         }
 154
 155
 156
 157
 158         /**
 159          * Begins editing on a cell_editable. event is the GdkEvent that began the
 160          * editing process. It may be NULL, in the instance that editing was initiated
 161          * through programatic means.
 162          * cell_editable:
 163          *  A GtkCellEditable
 164          * event:
 165          *  A GdkEvent, or NULL
 166          */
 167         public void startEditing(Event event)
 168         {
 169                 // void gtk_cell_editable_start_editing (GtkCellEditable *cell_editable,  GdkEvent *event);
 170                 gtk_cell_editable_start_editing(gtkCellEditable, (event is null) ? null : event.getEventStruct());
 171         }
 172
 173         /**
 174          * Emits the "editing_done" signal. This signal is a sign for the cell renderer
 175          * to update its value from the cell.
 176          * cell_editable:
 177          *  A GtkTreeEditable
 178          */
 179         public void editingDone()
 180         {
 181                 // void gtk_cell_editable_editing_done (GtkCellEditable *cell_editable);
 182                 gtk_cell_editable_editing_done(gtkCellEditable);
 183         }
 184
 185         /**
 186          * Emits the "remove_widget" signal. This signal is meant to indicate that the
 187          * cell is finished editing, and the widget may now be destroyed.
 188          * cell_editable:
 189          *  A GtkTreeEditable
 190          * Signal Details
 191          * The "editing-done" signal
 192          * void user_function (GtkCellEditable *celleditable,
 193          *  gpointer user_data) : Run last
 194          * celleditable:
 195          * the object which received the signal.
 196          * user_data:
 197          * user data set when the signal handler was connected.
 198          */
 199         public void removeWidget()
 200         {
 201                 // void gtk_cell_editable_remove_widget (GtkCellEditable *cell_editable);
 202                 gtk_cell_editable_remove_widget(gtkCellEditable);
 203         }
 204
 205 }