src/gtk/ScrolledWindow.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  = GtkScrolledWindow.html
  26  * outPack = gtk
  27  * outFile = ScrolledWindow
  28  * strct   = GtkScrolledWindow
  29  * realStrct=
  30  * ctorStrct=
  31  * clss    = ScrolledWindow
  32  * interf  =
  33  * class Code: Yes
  34  * interface Code: No
  35  * template for:
  36  * extend  =
  37  * implements:
  38  * prefixes:
  39  *      - gtk_scrolled_window_
  40  *      - gtk_
  41  * omit structs:
  42  * omit prefixes:
  43  * omit code:
  44  *      - gtk_scrolled_window_new
  45  * imports:
  46  *      - gtk.Widget
  47  *      - gtk.Adjustment
  48  * structWrap:
  49  *      - GtkAdjustment* -> Adjustment
  50  *      - GtkWidget* -> Widget
  51  * local aliases:
  52  */
  53
  54 module gtk.ScrolledWindow;
  55
  56 private import gtk.gtktypes;
  57
  58 private import lib.gtk;
  59
  60 private import gtk.Widget;
  61 private import gtk.Adjustment;
  62
  63 /**
  64  * Description
  65  * GtkScrolledWindow is a GtkBin subclass: it's a container
  66  * the accepts a single child widget. GtkScrolledWindow adds scrollbars
  67  * to the child widget and optionally draws a beveled frame around the
  68  * child widget.
  69  * The scrolled window can work in two ways. Some widgets have native
  70  * scrolling support; these widgets have "slots" for GtkAdjustment
  71  * objects.
  72  * [5]
  73  * Widgets with native scroll support include GtkTreeView, GtkTextView,
  74  * and GtkLayout.
  75  * For widgets that lack native scrolling support, the GtkViewport
  76  * widget acts as an adaptor class, implementing scrollability for child
  77  * widgets that lack their own scrolling capabilities. Use GtkViewport
  78  * to scroll child widgets such as GtkTable, GtkBox, and so on.
  79  * If a widget has native scrolling abilities, it can be added to the
  80  * GtkScrolledWindow with gtk_container_add(). If a widget does not, you
  81  * must first add the widget to a GtkViewport, then add the GtkViewport
  82  * to the scrolled window. The convenience function
  83  * gtk_scrolled_window_add_with_viewport() does exactly this, so you can
  84  * ignore the presence of the viewport.
  85  * The position of the scrollbars is controlled by the scroll
  86  * adjustments. See GtkAdjustment for the fields in an adjustment - for
  87  * GtkScrollbar, used by GtkScrolledWindow, the "value" field
  88  * represents the position of the scrollbar, which must be between the
  89  * "lower" field and "upper - page_size." The "page_size" field
  90  * represents the size of the visible scrollable area. The
  91  * "step_increment" and "page_increment" fields are used when the user
  92  * asks to step down (using the small stepper arrows) or page down (using
  93  * for example the PageDown key).
  94  * If a GtkScrolledWindow doesn't behave quite as you would like, or
  95  * doesn't have exactly the right layout, it's very possible to set up
  96  * your own scrolling with GtkScrollbar and for example a GtkTable.
  97  */
  98 private import gtk.Bin;
  99 public class ScrolledWindow : Bin
 100 {
 101
 102         /** the main Gtk struct */
 103         protected GtkScrolledWindow* gtkScrolledWindow;
 104
 105
 106         public GtkScrolledWindow* getScrolledWindowStruct()
 107         {
 108                 return gtkScrolledWindow;
 109         }
 110
 111
 112         /** the main Gtk struct as a void* */
 113         protected void* getStruct()
 114         {
 115                 return cast(void*)gtkScrolledWindow;
 116         }
 117
 118         /**
 119          * Sets our main struct and passes it to the parent class
 120          */
 121         public this (GtkScrolledWindow* gtkScrolledWindow)
 122         {
 123                 super(cast(GtkBin*)gtkScrolledWindow);
 124                 this.gtkScrolledWindow = gtkScrolledWindow;
 125         }
 126
 127         public this()
 128         {
 129                 this(null, null);
 130         }
 131
 132         public this(Widget widget)
 133         {
 134                 this();
 135                 addWithViewport(widget);
 136         }
 137
 138         /**
 139          * Creates a new scrolled window. The two arguments are the scrolled
 140          * window's adjustments; these will be shared with the scrollbars and the
 141          * child widget to keep the bars in sync with the child. Usually you want
 142          * to pass NULL for the adjustments, which will cause the scrolled window
 143          * to create them for you.
 144          * hadjustment:
 145          * Horizontal adjustment.
 146          * vadjustment:
 147          * Vertical adjustment.
 148          * Returns:
 149          * New scrolled window.
 150          */
 151         public this (Adjustment hadjustment, Adjustment vadjustment)
 152         {
 153                 // GtkWidget* gtk_scrolled_window_new (GtkAdjustment *hadjustment,  GtkAdjustment *vadjustment);
 154                 this(cast(GtkScrolledWindow*)gtk_scrolled_window_new(
 155                 hadjustment is null ? null : hadjustment.getAdjustmentStruct(),
 156                 vadjustment is null ? null : vadjustment.getAdjustmentStruct())
 157                 );
 158         }
 159
 160         /**
 161          * Creates a new Scrolled window and set the policy type
 162          * @param hPolicy the horizontal policy
 163          * @param vPolicy the vertical policy
 164          */
 165         this(PolicyType hPolicy, PolicyType vPolicy)
 166         {
 167                 this();
 168                 setPolicy(hPolicy, vPolicy);
 169         }
 170
 171         /**
 172          */
 173
 174         // imports for the signal processing
 175         private import gobject.Signals;
 176         private import gdk.gdktypes;
 177         int[char[]] connectedSignals;
 178
 179         void delegate(GtkDirectionType, ScrolledWindow)[] onMoveFocusOutListeners;
 180         void addOnMoveFocusOut(void delegate(GtkDirectionType, ScrolledWindow) dlg)
 181         {
 182                 if ( !("move-focus-out" in connectedSignals) )
 183                 {
 184                         Signals.connectData(
 185                         getStruct(),
 186                         "move-focus-out",
 187                         cast(GCallback)&callBackMoveFocusOut,
 188                         this,
 189                         null,
 190                         cast(ConnectFlags)0);
 191                         connectedSignals["move-focus-out"] = 1;
 192                 }
 193                 onMoveFocusOutListeners ~= dlg;
 194         }
 195         extern(C) static void callBackMoveFocusOut(GtkScrolledWindow* scrolledwindowStruct, GtkDirectionType arg1, ScrolledWindow scrolledWindow)
 196         {
 197                 bit consumed = false;
 198
 199                 foreach ( void delegate(GtkDirectionType, ScrolledWindow) dlg ; scrolledWindow.onMoveFocusOutListeners )
 200                 {
 201                         dlg(arg1, scrolledWindow);
 202                 }
 203
 204                 return consumed;
 205         }
 206
 207         void delegate(GtkScrollType, gboolean, ScrolledWindow)[] onScrollChildListeners;
 208         void addOnScrollChild(void delegate(GtkScrollType, gboolean, ScrolledWindow) dlg)
 209         {
 210                 if ( !("scroll-child" in connectedSignals) )
 211                 {
 212                         Signals.connectData(
 213                         getStruct(),
 214                         "scroll-child",
 215                         cast(GCallback)&callBackScrollChild,
 216                         this,
 217                         null,
 218                         cast(ConnectFlags)0);
 219                         connectedSignals["scroll-child"] = 1;
 220                 }
 221                 onScrollChildListeners ~= dlg;
 222         }
 223         extern(C) static void callBackScrollChild(GtkScrolledWindow* scrolledwindowStruct, GtkScrollType arg1, gboolean arg2, ScrolledWindow scrolledWindow)
 224         {
 225                 bit consumed = false;
 226
 227                 foreach ( void delegate(GtkScrollType, gboolean, ScrolledWindow) dlg ; scrolledWindow.onScrollChildListeners )
 228                 {
 229                         dlg(arg1, arg2, scrolledWindow);
 230                 }
 231
 232                 return consumed;
 233         }
 234
 235
 236
 237
 238         /**
 239          * Returns the horizontal scrollbar's adjustment, used to connect the
 240          * horizontal scrollbar to the child widget's horizontal scroll
 241          * functionality.
 242          * scrolled_window:
 243          * A GtkScrolledWindow.
 244          * Returns:
 245          * The horizontal GtkAdjustment.
 246          */
 247         public Adjustment getHadjustment()
 248         {
 249                 // GtkAdjustment* gtk_scrolled_window_get_hadjustment  (GtkScrolledWindow *scrolled_window);
 250                 return new Adjustment( gtk_scrolled_window_get_hadjustment(gtkScrolledWindow) );
 251         }
 252
 253         /**
 254          * Returns the vertical scrollbar's adjustment, used to connect the
 255          * vertical scrollbar to the child widget's vertical scroll
 256          * functionality.
 257          * scrolled_window:
 258          * A GtkScrolledWindow.
 259          * Returns:
 260          * The vertical GtkAdjustment.
 261          */
 262         public Adjustment getVadjustment()
 263         {
 264                 // GtkAdjustment* gtk_scrolled_window_get_vadjustment  (GtkScrolledWindow *scrolled_window);
 265                 return new Adjustment( gtk_scrolled_window_get_vadjustment(gtkScrolledWindow) );
 266         }
 267
 268         /**
 269          * Returns the horizontal scrollbar of scrolled_window.
 270          * scrolled_window:
 271          *  a GtkScrolledWindow
 272          * Returns:
 273          *  the horizontal scrollbar of the scrolled window, or
 274          *  NULL if it does not have one.
 275          * Since 2.8
 276          */
 277         public Widget getHscrollbar()
 278         {
 279                 // GtkWidget* gtk_scrolled_window_get_hscrollbar  (GtkScrolledWindow *scrolled_window);
 280                 return new Widget( gtk_scrolled_window_get_hscrollbar(gtkScrolledWindow) );
 281         }
 282
 283         /**
 284          * Returns the vertical scrollbar of scrolled_window.
 285          * scrolled_window:
 286          *  a GtkScrolledWindow
 287          * Returns:
 288          *  the vertical scrollbar of the scrolled window, or
 289          *  NULL if it does not have one.
 290          * Since 2.8
 291          */
 292         public Widget getVscrollbar()
 293         {
 294                 // GtkWidget* gtk_scrolled_window_get_vscrollbar  (GtkScrolledWindow *scrolled_window);
 295                 return new Widget( gtk_scrolled_window_get_vscrollbar(gtkScrolledWindow) );
 296         }
 297
 298         /**
 299          * Sets the scrollbar policy for the horizontal and vertical scrollbars.
 300          * The policy determines when the scrollbar should appear; it is a value
 301          * from the GtkPolicyType enumeration. If GTK_POLICY_ALWAYS, the
 302          * scrollbar is always present; if GTK_POLICY_NEVER, the scrollbar is
 303          * never present; if GTK_POLICY_AUTOMATIC, the scrollbar is present only
 304          * if needed (that is, if the slider part of the bar would be smaller
 305          * than the trough - the display is larger than the page size).
 306          * scrolled_window:
 307          * A GtkScrolledWindow.
 308          * hscrollbar_policy:
 309          * Policy for horizontal bar.
 310          * vscrollbar_policy:
 311          * Policy for vertical bar.
 312          */
 313         public void setPolicy(GtkPolicyType hscrollbarPolicy, GtkPolicyType vscrollbarPolicy)
 314         {
 315                 // void gtk_scrolled_window_set_policy (GtkScrolledWindow *scrolled_window,  GtkPolicyType hscrollbar_policy,  GtkPolicyType vscrollbar_policy);
 316                 gtk_scrolled_window_set_policy(gtkScrolledWindow, hscrollbarPolicy, vscrollbarPolicy);
 317         }
 318
 319         /**
 320          * Used to add children without native scrolling capabilities. This is
 321          * simply a convenience function; it is equivalent to adding the
 322          * unscrollable child to a viewport, then adding the viewport to the
 323          * scrolled window. If a child has native scrolling, use
 324          * gtk_container_add() instead of this function.
 325          * The viewport scrolls the child by moving its GdkWindow, and takes the
 326          * size of the child to be the size of its toplevel GdkWindow. This will
 327          * be very wrong for most widgets that support native scrolling; for
 328          * example, if you add a widget such as GtkTreeView with a viewport, the
 329          * whole widget will scroll, including the column headings. Thus, widgets
 330          * with native scrolling support should not be used with the GtkViewport proxy.
 331          * A widget supports scrolling natively if the
 332          * set_scroll_adjustments_signal field in GtkWidgetClass is non-zero,
 333          * i.e. has been filled in with a valid signal identifier.
 334          * scrolled_window:
 335          * A GtkScrolledWindow.
 336          * child:
 337          * Widget you want to scroll.
 338          */
 339         public void addWithViewport(Widget child)
 340         {
 341                 // void gtk_scrolled_window_add_with_viewport  (GtkScrolledWindow *scrolled_window,  GtkWidget *child);
 342                 gtk_scrolled_window_add_with_viewport(gtkScrolledWindow, (child is null) ? null : child.getWidgetStruct());
 343         }
 344
 345         /**
 346          * Sets the placement of the contents with respect to the scrollbars
 347          * for the scrolled window.
 348          * See also gtk_scrolled_window_get_placement() and
 349          * gtk_scrolled_window_unset_placement().
 350          * Determines the location of the child widget with respect to the
 351          * scrollbars. The default is GTK_CORNER_TOP_LEFT, meaning the child is
 352          * in the top left, with the scrollbars underneath and to the right.
 353          * Other values in GtkCornerType are GTK_CORNER_TOP_RIGHT,
 354          * GTK_CORNER_BOTTOM_LEFT, and GTK_CORNER_BOTTOM_RIGHT.
 355          * scrolled_window:
 356          *  a GtkScrolledWindow
 357          * window_placement:
 358          * Position of the child window.
 359          */
 360         public void setPlacement(GtkCornerType windowPlacement)
 361         {
 362                 // void gtk_scrolled_window_set_placement  (GtkScrolledWindow *scrolled_window,  GtkCornerType window_placement);
 363                 gtk_scrolled_window_set_placement(gtkScrolledWindow, windowPlacement);
 364         }
 365
 366         /**
 367          * Unsets the placement of the contents with respect to the scrollbars
 368          * for the scrolled window. If no window placement is set for a scrolled
 369          * window, it obeys the "gtk-scrolled-window-placement" XSETTING.
 370          * See also gtk_scrolled_window_set_placement() and
 371          * gtk_scrolled_window_get_placement().
 372          * scrolled_window:
 373          *  a GtkScrolledWindow
 374          * Since 2.10
 375          */
 376         public void unsetPlacement()
 377         {
 378                 // void gtk_scrolled_window_unset_placement  (GtkScrolledWindow *scrolled_window);
 379                 gtk_scrolled_window_unset_placement(gtkScrolledWindow);
 380         }
 381
 382         /**
 383          * Changes the type of shadow drawn around the contents of
 384          * scrolled_window.
 385          * scrolled_window:
 386          *  a GtkScrolledWindow
 387          * type:
 388          *  kind of shadow to draw around scrolled window contents
 389          */
 390         public void setShadowType(GtkShadowType type)
 391         {
 392                 // void gtk_scrolled_window_set_shadow_type  (GtkScrolledWindow *scrolled_window,  GtkShadowType type);
 393                 gtk_scrolled_window_set_shadow_type(gtkScrolledWindow, type);
 394         }
 395
 396         /**
 397          * Sets the GtkAdjustment for the horizontal scrollbar.
 398          * scrolled_window:
 399          * A GtkScrolledWindow.
 400          * hadjustment:
 401          * Horizontal scroll adjustment.
 402          */
 403         public void setHadjustment(Adjustment hadjustment)
 404         {
 405                 // void gtk_scrolled_window_set_hadjustment  (GtkScrolledWindow *scrolled_window,  GtkAdjustment *hadjustment);
 406                 gtk_scrolled_window_set_hadjustment(gtkScrolledWindow, (hadjustment is null) ? null : hadjustment.getAdjustmentStruct());
 407         }
 408
 409         /**
 410          * Sets the GtkAdjustment for the vertical scrollbar.
 411          * scrolled_window:
 412          * A GtkScrolledWindow.
 413          * vadjustment:
 414          * Vertical scroll adjustment.
 415          */
 416         public void setVadjustment(Adjustment vadjustment)
 417         {
 418                 // void gtk_scrolled_window_set_vadjustment  (GtkScrolledWindow *scrolled_window,  GtkAdjustment *vadjustment);
 419                 gtk_scrolled_window_set_vadjustment(gtkScrolledWindow, (vadjustment is null) ? null : vadjustment.getAdjustmentStruct());
 420         }
 421
 422         /**
 423          * Gets the placement of the contents with respect to the scrollbars
 424          * for the scrolled window. See gtk_scrolled_window_set_placement().
 425          * scrolled_window:
 426          *  a GtkScrolledWindow
 427          * Returns:
 428          *  the current placement value.
 429          * See also gtk_scrolled_window_set_placement() and
 430          * gtk_scrolled_window_unset_placement().
 431          */
 432         public GtkCornerType getPlacement()
 433         {
 434                 // GtkCornerType gtk_scrolled_window_get_placement  (GtkScrolledWindow *scrolled_window);
 435                 return gtk_scrolled_window_get_placement(gtkScrolledWindow);
 436         }
 437
 438         /**
 439          * Retrieves the current policy values for the horizontal and vertical
 440          * scrollbars. See gtk_scrolled_window_set_policy().
 441          * scrolled_window:
 442          *  a GtkScrolledWindow
 443          * hscrollbar_policy:
 444          *  location to store the policy for the horizontal scrollbar, or NULL.
 445          * vscrollbar_policy:
 446          *  location to store the policy for the horizontal scrollbar, or NULL.
 447          */
 448         public void getPolicy(GtkPolicyType* hscrollbarPolicy, GtkPolicyType* vscrollbarPolicy)
 449         {
 450                 // void gtk_scrolled_window_get_policy (GtkScrolledWindow *scrolled_window,  GtkPolicyType *hscrollbar_policy,  GtkPolicyType *vscrollbar_policy);
 451                 gtk_scrolled_window_get_policy(gtkScrolledWindow, hscrollbarPolicy, vscrollbarPolicy);
 452         }
 453
 454         /**
 455          * Gets the shadow type of the scrolled window. See
 456          * gtk_scrolled_window_set_shadow_type().
 457          * scrolled_window:
 458          *  a GtkScrolledWindow
 459          * Returns:
 460          *  the current shadow type
 461          * Property Details
 462          * The "hadjustment" property
 463          *  "hadjustment" GtkAdjustment : Read / Write / Construct
 464          * The GtkAdjustment for the horizontal position.
 465          */
 466         public GtkShadowType getShadowType()
 467         {
 468                 // GtkShadowType gtk_scrolled_window_get_shadow_type  (GtkScrolledWindow *scrolled_window);
 469                 return gtk_scrolled_window_get_shadow_type(gtkScrolledWindow);
 470         }
 471
 472
 473
 474
 475
 476
 477
 478 }