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 6 * as published by the Free Software Foundation; either version 3 7 * of the License, or (at your option) any later version, with 8 * some exceptions, please read the COPYING file. 9 * 10 * gtkD is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU Lesser General Public License for more details. 14 * 15 * You should have received a copy of the GNU Lesser General Public License 16 * along with gtkD; if not, write to the Free Software 17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA 18 */ 19 20 // generated automatically - do not change 21 // find conversion definition on APILookup.txt 22 // implement new conversion functionalities on the wrap.utils pakage 23 24 25 module gtk.Revealer; 26 27 private import glib.ConstructionException; 28 private import gobject.ObjectG; 29 private import gtk.Bin; 30 private import gtk.Widget; 31 private import gtkc.gtk; 32 public import gtkc.gtktypes; 33 34 35 /** 36 * The GtkRevealer widget is a container which animates 37 * the transition of its child from invisible to visible. 38 * 39 * The style of transition can be controlled with 40 * gtk_revealer_set_transition_type(). 41 * 42 * These animations respect the #GtkSettings:gtk-enable-animations 43 * setting. 44 * 45 * # CSS nodes 46 * 47 * GtkRevealer has a single CSS node with name revealer. 48 * 49 * The GtkRevealer widget was added in GTK+ 3.10. 50 */ 51 public class Revealer : Bin 52 { 53 /** the main Gtk struct */ 54 protected GtkRevealer* gtkRevealer; 55 56 /** Get the main Gtk struct */ 57 public GtkRevealer* getRevealerStruct() 58 { 59 return gtkRevealer; 60 } 61 62 /** the main Gtk struct as a void* */ 63 protected override void* getStruct() 64 { 65 return cast(void*)gtkRevealer; 66 } 67 68 protected override void setStruct(GObject* obj) 69 { 70 gtkRevealer = cast(GtkRevealer*)obj; 71 super.setStruct(obj); 72 } 73 74 /** 75 * Sets our main struct and passes it to the parent class. 76 */ 77 public this (GtkRevealer* gtkRevealer, bool ownedRef = false) 78 { 79 this.gtkRevealer = gtkRevealer; 80 super(cast(GtkBin*)gtkRevealer, ownedRef); 81 } 82 83 84 /** */ 85 public static GType getType() 86 { 87 return gtk_revealer_get_type(); 88 } 89 90 /** 91 * Creates a new #GtkRevealer. 92 * 93 * Return: a newly created #GtkRevealer 94 * 95 * Since: 3.10 96 * 97 * Throws: ConstructionException GTK+ fails to create the object. 98 */ 99 public this() 100 { 101 auto p = gtk_revealer_new(); 102 103 if(p is null) 104 { 105 throw new ConstructionException("null returned by new"); 106 } 107 108 this(cast(GtkRevealer*) p); 109 } 110 111 /** 112 * Returns whether the child is fully revealed, ie wether 113 * the transition to the revealed state is completed. 114 * 115 * Return: %TRUE if the child is fully revealed 116 * 117 * Since: 3.10 118 */ 119 public bool getChildRevealed() 120 { 121 return gtk_revealer_get_child_revealed(gtkRevealer) != 0; 122 } 123 124 /** 125 * Returns whether the child is currently 126 * revealed. See gtk_revealer_set_reveal_child(). 127 * 128 * This function returns %TRUE as soon as the transition 129 * is to the revealed state is started. To learn whether 130 * the child is fully revealed (ie the transition is completed), 131 * use gtk_revealer_get_child_revealed(). 132 * 133 * Return: %TRUE if the child is revealed. 134 * 135 * Since: 3.10 136 */ 137 public bool getRevealChild() 138 { 139 return gtk_revealer_get_reveal_child(gtkRevealer) != 0; 140 } 141 142 /** 143 * Returns the amount of time (in milliseconds) that 144 * transitions will take. 145 * 146 * Return: the transition duration 147 * 148 * Since: 3.10 149 */ 150 public uint getTransitionDuration() 151 { 152 return gtk_revealer_get_transition_duration(gtkRevealer); 153 } 154 155 /** 156 * Gets the type of animation that will be used 157 * for transitions in @revealer. 158 * 159 * Return: the current transition type of @revealer 160 * 161 * Since: 3.10 162 */ 163 public GtkRevealerTransitionType getTransitionType() 164 { 165 return gtk_revealer_get_transition_type(gtkRevealer); 166 } 167 168 /** 169 * Tells the #GtkRevealer to reveal or conceal its child. 170 * 171 * The transition will be animated with the current 172 * transition type of @revealer. 173 * 174 * Params: 175 * revealChild = %TRUE to reveal the child 176 * 177 * Since: 3.10 178 */ 179 public void setRevealChild(bool revealChild) 180 { 181 gtk_revealer_set_reveal_child(gtkRevealer, revealChild); 182 } 183 184 /** 185 * Sets the duration that transitions will take. 186 * 187 * Params: 188 * duration = the new duration, in milliseconds 189 * 190 * Since: 3.10 191 */ 192 public void setTransitionDuration(uint duration) 193 { 194 gtk_revealer_set_transition_duration(gtkRevealer, duration); 195 } 196 197 /** 198 * Sets the type of animation that will be used for 199 * transitions in @revealer. Available types include 200 * various kinds of fades and slides. 201 * 202 * Params: 203 * transition = the new transition type 204 * 205 * Since: 3.10 206 */ 207 public void setTransitionType(GtkRevealerTransitionType transition) 208 { 209 gtk_revealer_set_transition_type(gtkRevealer, transition); 210 } 211 }