gtkD/src/gtk/HandleBox.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  = GtkHandleBox.html
  26  * outPack = gtk
  27  * outFile = HandleBox
  28  * strct   = GtkHandleBox
  29  * realStrct=
  30  * ctorStrct=
  31  * clss    = HandleBox
  32  * interf  =
  33  * class Code: No
  34  * interface Code: No
  35  * template for:
  36  * extend  =
  37  * implements:
  38  * prefixes:
  39  *      - gtk_handle_box_
  40  *      - gtk_
  41  * omit structs:
  42  * omit prefixes:
  43  * omit code:
  44  * imports:
  45  * structWrap:
  46  * module aliases:
  47  * local aliases:
  48  */
  49
  50 module gtk.HandleBox;
  51
  52 version(noAssert)
  53 {
  54         version(Tango)
  55         {
  56                 import tango.io.Stdout; // use the tango loging?
  57         }
  58 }
  59
  60 private import gtkc.gtktypes;
  61
  62 private import gtkc.gtk;
  63
  64
  65
  66
  67
  68
  69 /**
  70  * Description
  71  * The GtkHandleBox widget allows a portion of a window to be "torn
  72  * off". It is a bin widget which displays its child and a handle that
  73  * the user can drag to tear off a separate window (the float
  74  * window) containing the child widget. A thin
  75  * ghost is drawn in the original location of the
  76  * handlebox. By dragging the separate window back to its original
  77  * location, it can be reattached.
  78  * When reattaching, the ghost and float window, must be aligned
  79  * along one of the edges, the snap edge.
  80  * This either can be specified by the application programmer
  81  * explicitely, or GTK+ will pick a reasonable default based
  82  * on the handle position.
  83  * To make detaching and reattaching the handlebox as minimally confusing
  84  * as possible to the user, it is important to set the snap edge so that
  85  * the snap edge does not move when the handlebox is deattached. For
  86  * instance, if the handlebox is packed at the bottom of a VBox, then
  87  * when the handlebox is detached, the bottom edge of the handlebox's
  88  * allocation will remain fixed as the height of the handlebox shrinks,
  89  * so the snap edge should be set to GTK_POS_BOTTOM.
  90  */
  91 private import gtk.Bin;
  92 public class HandleBox : Bin
  93 {
  94
  95         /** the main Gtk struct */
  96         protected GtkHandleBox* gtkHandleBox;
  97
  98
  99         public GtkHandleBox* getHandleBoxStruct()
 100         {
 101                 return gtkHandleBox;
 102         }
 103
 104
 105         /** the main Gtk struct as a void* */
 106         protected void* getStruct()
 107         {
 108                 return cast(void*)gtkHandleBox;
 109         }
 110
 111         /**
 112          * Sets our main struct and passes it to the parent class
 113          */
 114         public this (GtkHandleBox* gtkHandleBox)
 115         {
 116                 version(noAssert)
 117                 {
 118                         if ( gtkHandleBox is null )
 119                         {
 120                                 int zero = 0;
 121                                 version(Tango)
 122                                 {
 123                                         Stdout("struct gtkHandleBox is null on constructor").newline;
 124                                 }
 125                                 else
 126                                 {
 127                                         printf("struct gtkHandleBox is null on constructor");
 128                                 }
 129                                 zero = zero / zero;
 130                         }
 131                 }
 132                 else
 133                 {
 134                         assert(gtkHandleBox !is null, "struct gtkHandleBox is null on constructor");
 135                 }
 136                 super(cast(GtkBin*)gtkHandleBox);
 137                 this.gtkHandleBox = gtkHandleBox;
 138         }
 139
 140         /**
 141          */
 142
 143         // imports for the signal processing
 144         private import gobject.Signals;
 145         private import gtkc.gdktypes;
 146         int[char[]] connectedSignals;
 147
 148         void delegate(GtkWidget*, HandleBox)[] onChildAttachedListeners;
 149         void addOnChildAttached(void delegate(GtkWidget*, HandleBox) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
 150         {
 151                 if ( !("child-attached" in connectedSignals) )
 152                 {
 153                         Signals.connectData(
 154                         getStruct(),
 155                         "child-attached",
 156                         cast(GCallback)&callBackChildAttached,
 157                         cast(void*)this,
 158                         null,
 159                         connectFlags);
 160                         connectedSignals["child-attached"] = 1;
 161                 }
 162                 onChildAttachedListeners ~= dlg;
 163         }
 164         extern(C) static void callBackChildAttached(GtkHandleBox* handleboxStruct, GtkWidget* widget, HandleBox handleBox)
 165         {
 166                 bool consumed = false;
 167
 168                 foreach ( void delegate(GtkWidget*, HandleBox) dlg ; handleBox.onChildAttachedListeners )
 169                 {
 170                         dlg(widget, handleBox);
 171                 }
 172
 173                 return consumed;
 174         }
 175
 176         void delegate(GtkWidget*, HandleBox)[] onChildDetachedListeners;
 177         void addOnChildDetached(void delegate(GtkWidget*, HandleBox) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
 178         {
 179                 if ( !("child-detached" in connectedSignals) )
 180                 {
 181                         Signals.connectData(
 182                         getStruct(),
 183                         "child-detached",
 184                         cast(GCallback)&callBackChildDetached,
 185                         cast(void*)this,
 186                         null,
 187                         connectFlags);
 188                         connectedSignals["child-detached"] = 1;
 189                 }
 190                 onChildDetachedListeners ~= dlg;
 191         }
 192         extern(C) static void callBackChildDetached(GtkHandleBox* handleboxStruct, GtkWidget* widget, HandleBox handleBox)
 193         {
 194                 bool consumed = false;
 195
 196                 foreach ( void delegate(GtkWidget*, HandleBox) dlg ; handleBox.onChildDetachedListeners )
 197                 {
 198                         dlg(widget, handleBox);
 199                 }
 200
 201                 return consumed;
 202         }
 203
 204
 205
 206         /**
 207          * Create a new handle box.
 208          * Returns:
 209          * a new GtkHandleBox.
 210          */
 211         public this ()
 212         {
 213                 // GtkWidget* gtk_handle_box_new (void);
 214                 this(cast(GtkHandleBox*)gtk_handle_box_new() );
 215         }
 216
 217         /**
 218          * Sets the type of shadow to be drawn around the border
 219          * of the handle box.
 220          * handle_box:
 221          * a GtkHandleBox
 222          * type:
 223          * the shadow type.
 224          */
 225         public void setShadowType(GtkShadowType type)
 226         {
 227                 // void gtk_handle_box_set_shadow_type (GtkHandleBox *handle_box,  GtkShadowType type);
 228                 gtk_handle_box_set_shadow_type(gtkHandleBox, type);
 229         }
 230
 231         /**
 232          * Sets the side of the handlebox where the handle is drawn.
 233          * handle_box:
 234          * a GtkHandleBox
 235          * position:
 236          * the side of the handlebox where the handle should be drawn.
 237          */
 238         public void setHandlePosition(GtkPositionType position)
 239         {
 240                 // void gtk_handle_box_set_handle_position (GtkHandleBox *handle_box,  GtkPositionType position);
 241                 gtk_handle_box_set_handle_position(gtkHandleBox, position);
 242         }
 243
 244         /**
 245          * Sets the snap edge of a handlebox. The snap edge is
 246          * the edge of the detached child that must be aligned
 247          * with the corresponding edge of the "ghost" left
 248          * behind when the child was detached to reattach
 249          * the torn-off window. Usually, the snap edge should
 250          * be chosen so that it stays in the same place on
 251          * the screen when the handlebox is torn off.
 252          * If the snap edge is not set, then an appropriate value
 253          * will be guessed from the handle position. If the
 254          * handle position is GTK_POS_RIGHT or GTK_POS_LEFT,
 255          * then the snap edge will be GTK_POS_TOP, otherwise
 256          * it will be GTK_POS_LEFT.
 257          * handle_box:
 258          * a GtkHandleBox
 259          * edge:
 260          * the snap edge, or -1 to unset the value; in which
 261          * case GTK+ will try to guess an appropriate value
 262          * in the future.
 263          */
 264         public void setSnapEdge(GtkPositionType edge)
 265         {
 266                 // void gtk_handle_box_set_snap_edge (GtkHandleBox *handle_box,  GtkPositionType edge);
 267                 gtk_handle_box_set_snap_edge(gtkHandleBox, edge);
 268         }
 269
 270         /**
 271          * Gets the handle position of the handle box. See
 272          * gtk_handle_box_set_handle_position().
 273          * handle_box:
 274          *  a GtkHandleBox
 275          * Returns:
 276          *  the current handle position.
 277          */
 278         public GtkPositionType getHandlePosition()
 279         {
 280                 // GtkPositionType gtk_handle_box_get_handle_position (GtkHandleBox *handle_box);
 281                 return gtk_handle_box_get_handle_position(gtkHandleBox);
 282         }
 283
 284         /**
 285          * Gets the type of shadow drawn around the handle box. See
 286          * gtk_handle_box_set_shadow_type().
 287          * handle_box:
 288          *  a GtkHandleBox
 289          * Returns:
 290          *  the type of shadow currently drawn around the handle box.
 291          */
 292         public GtkShadowType getShadowType()
 293         {
 294                 // GtkShadowType gtk_handle_box_get_shadow_type (GtkHandleBox *handle_box);
 295                 return gtk_handle_box_get_shadow_type(gtkHandleBox);
 296         }
 297
 298         /**
 299          * Gets the edge used for determining reattachment of the handle box. See
 300          * gtk_handle_box_set_snap_edge().
 301          * handle_box:
 302          *  a GtkHandleBox
 303          * Returns:
 304          *  the edge used for determining reattachment, or (GtkPositionType)-1 if this
 305          *  is determined (as per default) from the handle position.
 306          * Property Details
 307          * The "handle-position" property
 308          *  "handle-position" GtkPositionType : Read / Write
 309          * Position of the handle relative to the child widget.
 310          * Default value: GTK_POS_LEFT
 311          */
 312         public GtkPositionType getSnapEdge()
 313         {
 314                 // GtkPositionType gtk_handle_box_get_snap_edge (GtkHandleBox *handle_box);
 315                 return gtk_handle_box_get_snap_edge(gtkHandleBox);
 316         }
 317
 318
 319
 320
 321
 322 }