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 * The GtkRevealer widget was added in GTK+ 3.10. 46 */ 47 public class Revealer : Bin 48 { 49 /** the main Gtk struct */ 50 protected GtkRevealer* gtkRevealer; 51 52 /** Get the main Gtk struct */ 53 public GtkRevealer* getRevealerStruct() 54 { 55 return gtkRevealer; 56 } 57 58 /** the main Gtk struct as a void* */ 59 protected override void* getStruct() 60 { 61 return cast(void*)gtkRevealer; 62 } 63 64 protected override void setStruct(GObject* obj) 65 { 66 gtkRevealer = cast(GtkRevealer*)obj; 67 super.setStruct(obj); 68 } 69 70 /** 71 * Sets our main struct and passes it to the parent class. 72 */ 73 public this (GtkRevealer* gtkRevealer, bool ownedRef = false) 74 { 75 this.gtkRevealer = gtkRevealer; 76 super(cast(GtkBin*)gtkRevealer, ownedRef); 77 } 78 79 /** 80 */ 81 82 public static GType getType() 83 { 84 return gtk_revealer_get_type(); 85 } 86 87 /** 88 * Creates a new #GtkRevealer. 89 * 90 * Return: a newly created #GtkRevealer 91 * 92 * Since: 3.10 93 * 94 * Throws: ConstructionException GTK+ fails to create the object. 95 */ 96 public this() 97 { 98 auto p = gtk_revealer_new(); 99 100 if(p is null) 101 { 102 throw new ConstructionException("null returned by new"); 103 } 104 105 this(cast(GtkRevealer*) p); 106 } 107 108 /** 109 * Returns whether the child is fully revealed, ie wether 110 * the transition to the revealed state is completed. 111 * 112 * Return: %TRUE if the child is fully revealed 113 * 114 * Since: 3.10 115 */ 116 public bool getChildRevealed() 117 { 118 return gtk_revealer_get_child_revealed(gtkRevealer) != 0; 119 } 120 121 /** 122 * Returns whether the child is currently 123 * revealed. See gtk_revealer_set_reveal_child(). 124 * 125 * This function returns %TRUE as soon as the transition 126 * is to the revealed state is started. To learn whether 127 * the child is fully revealed (ie the transition is completed), 128 * use gtk_revealer_get_child_revealed(). 129 * 130 * Return: %TRUE if the child is revealed. 131 * 132 * Since: 3.10 133 */ 134 public bool getRevealChild() 135 { 136 return gtk_revealer_get_reveal_child(gtkRevealer) != 0; 137 } 138 139 /** 140 * Returns the amount of time (in milliseconds) that 141 * transitions will take. 142 * 143 * Return: the transition duration 144 * 145 * Since: 3.10 146 */ 147 public uint getTransitionDuration() 148 { 149 return gtk_revealer_get_transition_duration(gtkRevealer); 150 } 151 152 /** 153 * Gets the type of animation that will be used 154 * for transitions in @revealer. 155 * 156 * Return: the current transition type of @revealer 157 * 158 * Since: 3.10 159 */ 160 public GtkRevealerTransitionType getTransitionType() 161 { 162 return gtk_revealer_get_transition_type(gtkRevealer); 163 } 164 165 /** 166 * Tells the #GtkRevealer to reveal or conceal its child. 167 * 168 * The transition will be animated with the current 169 * transition type of @revealer. 170 * 171 * Params: 172 * revealChild = %TRUE to reveal the child 173 * 174 * Since: 3.10 175 */ 176 public void setRevealChild(bool revealChild) 177 { 178 gtk_revealer_set_reveal_child(gtkRevealer, revealChild); 179 } 180 181 /** 182 * Sets the duration that transitions will take. 183 * 184 * Params: 185 * duration = the new duration, in milliseconds 186 * 187 * Since: 3.10 188 */ 189 public void setTransitionDuration(uint duration) 190 { 191 gtk_revealer_set_transition_duration(gtkRevealer, duration); 192 } 193 194 /** 195 * Sets the type of animation that will be used for 196 * transitions in @revealer. Available types include 197 * various kinds of fades and slides. 198 * 199 * Params: 200 * transition = the new transition type 201 * 202 * Since: 3.10 203 */ 204 public void setTransitionType(GtkRevealerTransitionType transition) 205 { 206 gtk_revealer_set_transition_type(gtkRevealer, transition); 207 } 208 }