src/gtk/InputDialog.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  = GtkInputDialog.html
  26  * outPack = gtk
  27  * outFile = InputDialog
  28  * strct   = GtkInputDialog
  29  * realStrct=
  30  * ctorStrct=
  31  * clss    = InputDialog
  32  * interf  =
  33  * class Code: No
  34  * interface Code: No
  35  * template for:
  36  * extend  =
  37  * implements:
  38  * prefixes:
  39  *      - gtk_input_dialog_
  40  *      - gtk_
  41  * omit structs:
  42  * omit prefixes:
  43  * omit code:
  44  * imports:
  45  * structWrap:
  46  * local aliases:
  47  */
  48
  49 module gtk.InputDialog;
  50
  51 private import gtk.gtktypes;
  52
  53 private import lib.gtk;
  54
  55
  56 /**
  57  * Description
  58  *  NOTE this widget is considered too specialized/little-used for
  59  *  GTK+, and will in the future be moved to some other package. If
  60  *  your application needs this widget, feel free to use it, as the
  61  *  widget does work and is useful in some applications; it's just not
  62  *  of general interest. However, we are not accepting new features for
  63  *  the widget, and it will eventually move out of the GTK+
  64  *  distribution.
  65  * GtkInputDialog displays a dialog which allows the user
  66  * to configure XInput extension devices. For each
  67  * device, they can control the mode of the device
  68  * (disabled, screen-relative, or window-relative),
  69  * the mapping of axes to coordinates, and the
  70  * mapping of the devices macro keys to key press
  71  * events.
  72  * GtkInputDialog contains two buttons to which
  73  * the application can connect; one for closing
  74  * the dialog, and one for saving the changes.
  75  * No actions are bound to these by default.
  76  * The changes that the user makes take effect
  77  * immediately.
  78  */
  79 private import gtk.Dialog;
  80 public class InputDialog : Dialog
  81 {
  82
  83         /** the main Gtk struct */
  84         protected GtkInputDialog* gtkInputDialog;
  85
  86
  87         public GtkInputDialog* getInputDialogStruct()
  88         {
  89                 return gtkInputDialog;
  90         }
  91
  92
  93         /** the main Gtk struct as a void* */
  94         protected void* getStruct()
  95         {
  96                 return cast(void*)gtkInputDialog;
  97         }
  98
  99         /**
 100          * Sets our main struct and passes it to the parent class
 101          */
 102         public this (GtkInputDialog* gtkInputDialog)
 103         {
 104                 super(cast(GtkDialog*)gtkInputDialog);
 105                 this.gtkInputDialog = gtkInputDialog;
 106         }
 107
 108         /**
 109          */
 110
 111         // imports for the signal processing
 112         private import gobject.Signals;
 113         private import gdk.gdktypes;
 114         int[char[]] connectedSignals;
 115
 116         void delegate(GdkDevice*, InputDialog)[] onDisableDeviceListeners;
 117         void addOnDisableDevice(void delegate(GdkDevice*, InputDialog) dlg)
 118         {
 119                 if ( !("disable-device" in connectedSignals) )
 120                 {
 121                         Signals.connectData(
 122                         getStruct(),
 123                         "disable-device",
 124                         cast(GCallback)&callBackDisableDevice,
 125                         this,
 126                         null,
 127                         cast(ConnectFlags)0);
 128                         connectedSignals["disable-device"] = 1;
 129                 }
 130                 onDisableDeviceListeners ~= dlg;
 131         }
 132         extern(C) static void callBackDisableDevice(GtkInputDialog* inputdialogStruct, GdkDevice* deviceid, InputDialog inputDialog)
 133         {
 134                 bit consumed = false;
 135
 136                 foreach ( void delegate(GdkDevice*, InputDialog) dlg ; inputDialog.onDisableDeviceListeners )
 137                 {
 138                         dlg(deviceid, inputDialog);
 139                 }
 140
 141                 return consumed;
 142         }
 143
 144         void delegate(GdkDevice*, InputDialog)[] onEnableDeviceListeners;
 145         void addOnEnableDevice(void delegate(GdkDevice*, InputDialog) dlg)
 146         {
 147                 if ( !("enable-device" in connectedSignals) )
 148                 {
 149                         Signals.connectData(
 150                         getStruct(),
 151                         "enable-device",
 152                         cast(GCallback)&callBackEnableDevice,
 153                         this,
 154                         null,
 155                         cast(ConnectFlags)0);
 156                         connectedSignals["enable-device"] = 1;
 157                 }
 158                 onEnableDeviceListeners ~= dlg;
 159         }
 160         extern(C) static void callBackEnableDevice(GtkInputDialog* inputdialogStruct, GdkDevice* deviceid, InputDialog inputDialog)
 161         {
 162                 bit consumed = false;
 163
 164                 foreach ( void delegate(GdkDevice*, InputDialog) dlg ; inputDialog.onEnableDeviceListeners )
 165                 {
 166                         dlg(deviceid, inputDialog);
 167                 }
 168
 169                 return consumed;
 170         }
 171
 172
 173
 174         /**
 175          * Creates a new GtkInputDialog.
 176          * Returns:
 177          * the new GtkInputDialog.
 178          * Signal Details
 179          * The "disable-device" signal
 180          * void user_function (GtkInputDialog *inputdialog,
 181          *  GdkDevice *deviceid,
 182          *  gpointer user_data) : Run last
 183          * This signal is emitted when the user changes the
 184          * mode of a device from a GDK_MODE_SCREEN or GDK_MODE_WINDOW
 185          * to GDK_MODE_ENABLED.
 186          * inputdialog:
 187          * the object which received the signal.
 188          * deviceid:
 189          * The ID of the newly disabled device.
 190          * user_data:
 191          * user data set when the signal handler was connected.
 192          */
 193         public this ()
 194         {
 195                 // GtkWidget* gtk_input_dialog_new (void);
 196                 this(cast(GtkInputDialog*)gtk_input_dialog_new() );
 197         }
 198
 199 }