src/gtk/EventBox.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  = GtkEventBox.html
  26  * outPack = gtk
  27  * outFile = EventBox
  28  * strct   = GtkEventBox
  29  * realStrct=
  30  * ctorStrct=
  31  * clss    = EventBox
  32  * interf  =
  33  * class Code: No
  34  * interface Code: No
  35  * template for:
  36  * extend  =
  37  * implements:
  38  * prefixes:
  39  *      - gtk_event_box_
  40  *      - gtk_
  41  * omit structs:
  42  * omit prefixes:
  43  * omit code:
  44  * imports:
  45  * structWrap:
  46  * local aliases:
  47  */
  48
  49 module gtk.EventBox;
  50
  51 private import gtk.gtktypes;
  52
  53 private import lib.gtk;
  54
  55
  56 /**
  57  * Description
  58  * The GtkEventBox widget is a subclass of GtkBin which also has its own window.
  59  * It is useful since it allows you to catch events for widgets which do not
  60  * have their own window.
  61  */
  62 private import gtk.Bin;
  63 public class EventBox : Bin
  64 {
  65
  66         /** the main Gtk struct */
  67         protected GtkEventBox* gtkEventBox;
  68
  69
  70         public GtkEventBox* getEventBoxStruct()
  71         {
  72                 return gtkEventBox;
  73         }
  74
  75
  76         /** the main Gtk struct as a void* */
  77         protected void* getStruct()
  78         {
  79                 return cast(void*)gtkEventBox;
  80         }
  81
  82         /**
  83          * Sets our main struct and passes it to the parent class
  84          */
  85         public this (GtkEventBox* gtkEventBox)
  86         {
  87                 super(cast(GtkBin*)gtkEventBox);
  88                 this.gtkEventBox = gtkEventBox;
  89         }
  90
  91         /**
  92          */
  93
  94
  95         /**
  96          * Creates a new GtkEventBox.
  97          * Returns:
  98          * a new GtkEventBox.
  99          */
 100         public this ()
 101         {
 102                 // GtkWidget* gtk_event_box_new (void);
 103                 this(cast(GtkEventBox*)gtk_event_box_new() );
 104         }
 105
 106         /**
 107          * Set whether the event box window is positioned above the windows of its child,
 108          * as opposed to below it. If the window is above, all events inside the
 109          * event box will go to the event box. If the window is below, events
 110          * in windows of child widgets will first got to that widget, and then
 111          * to its parents.
 112          * The default is to keep the window below the child.
 113          * event_box:
 114          *  a GtkEventBox
 115          * above_child:
 116          *  TRUE if the event box window is above the windows of its child
 117          * Since 2.4
 118          */
 119         public void setAboveChild(int aboveChild)
 120         {
 121                 // void gtk_event_box_set_above_child (GtkEventBox *event_box,  gboolean above_child);
 122                 gtk_event_box_set_above_child(gtkEventBox, aboveChild);
 123         }
 124
 125         /**
 126          * Returns whether the event box window is above or below the
 127          * windows of its child. See gtk_event_box_set_above_child() for
 128          * details.
 129          * event_box:
 130          *  a GtkEventBox
 131          * Returns:
 132          *  TRUE if the event box window is above the window
 133          * of its child.
 134          * Since 2.4
 135          */
 136         public int getAboveChild()
 137         {
 138                 // gboolean gtk_event_box_get_above_child (GtkEventBox *event_box);
 139                 return gtk_event_box_get_above_child(gtkEventBox);
 140         }
 141
 142         /**
 143          * Set whether the event box uses a visible or invisible child
 144          * window. The default is to use visible windows.
 145          * In an invisible window event box, the window that the
 146          * event box creates is a GDK_INPUT_ONLY window, which
 147          * means that it is invisible and only serves to receive
 148          * events.
 149          * A visible window event box creates a visible (GDK_INPUT_OUTPUT)
 150          * window that acts as the parent window for all the widgets
 151          * contained in the event box.
 152          * You should generally make your event box invisible if
 153          * you just want to trap events. Creating a visible window
 154          * may cause artifacts that are visible to the user, especially
 155          * if the user is using a theme with gradients or pixmaps.
 156          * The main reason to create a non input-only event box is if
 157          * you want to set the background to a different color or
 158          * draw on it.
 159          * Note
 160          * There is one unexpected issue for an invisible event box that has its
 161          * window below the child. (See gtk_event_box_set_above_child().)
 162          * Since the input-only window is not an ancestor window of any windows
 163          * that descendent widgets of the event box create, events on these
 164          * windows aren't propagated up by the windowing system, but only by GTK+.
 165          * The practical effect of this is if an event isn't in the event
 166          * mask for the descendant window (see gtk_widget_add_events()),
 167          * it won't be received by the event box.
 168          * This problem doesn't occur for visible event boxes, because in
 169          * that case, the event box window is actually the ancestor of the
 170          * descendant windows, not just at the same place on the screen.
 171          * event_box:
 172          *  a GtkEventBox
 173          * visible_window:
 174          *  boolean value
 175          * Since 2.4
 176          */
 177         public void setVisibleWindow(int visibleWindow)
 178         {
 179                 // void gtk_event_box_set_visible_window  (GtkEventBox *event_box,  gboolean visible_window);
 180                 gtk_event_box_set_visible_window(gtkEventBox, visibleWindow);
 181         }
 182
 183         /**
 184          * Returns whether the event box has a visible window.
 185          * See gtk_event_box_set_visible_window() for details.
 186          * event_box:
 187          *  a GtkEventBox
 188          * Returns:
 189          *  TRUE if the event box window is visible
 190          * Since 2.4
 191          * Property Details
 192          * The "above-child" property
 193          *  "above-child" gboolean : Read / Write
 194          * Whether the event-trapping window of the eventbox is above the window of the child widget as opposed to below it.
 195          * Default value: FALSE
 196          */
 197         public int getVisibleWindow()
 198         {
 199                 // gboolean gtk_event_box_get_visible_window  (GtkEventBox *event_box);
 200                 return gtk_event_box_get_visible_window(gtkEventBox);
 201         }
 202
 203 }